@microsoft/fast-html 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/esm/components/utilities.spec.js

@@ -1,45 +1,90 @@
-import { __awaiter } from "tslib";
 import { expect, test } from "@playwright/test";
-import { getNextBehavior, getAllPartials, getIndexOfNextMatchingTag, pathResolver } from "./utilities.js";
-test.describe("utilities", () => __awaiter(void 0, void 0, void 0, function* () {
-    test.describe("content", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("get the next content binding", () => __awaiter(void 0, void 0, void 0, function* () {
+import { refPropertyName, Schema } from "./schema.js";
+import { getNextBehavior, getIndexOfNextMatchingTag, pathResolver, transformInnerHTML, getExpressionChain, extractPathsFromChainedExpression, getChildrenMap, findDef, resolveWhen, } from "./utilities.js";
+test.describe("utilities", async () => {
+    test.describe("content", async () => {
+        test("get the next content binding", async () => {
             const innerHTML = "{{text}}";
             const templateResult = getNextBehavior(innerHTML);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("dataBinding");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.subtype).toEqual("content");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.bindingType).toEqual("default");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingStartIndex).toEqual(0);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingEndIndex).toEqual(2);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingStartIndex).toEqual(6);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingEndIndex).toEqual(8);
-        }));
-    }));
-    test.describe("attributes", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("get the next attribute binding", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+    });
+    test.describe("attributes", async () => {
+        test("get the next attribute binding", async () => {
             const innerHTML = "<input type=\"{{type}}\" disabled>";
             const templateResult = getNextBehavior(innerHTML);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("dataBinding");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.subtype).toEqual("attribute");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.aspect).toEqual(null);
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.bindingType).toEqual("default");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingStartIndex).toEqual(13);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingEndIndex).toEqual(15);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingStartIndex).toEqual(19);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingEndIndex).toEqual(21);
-        }));
-        test("get the next attribute event binding", () => __awaiter(void 0, void 0, void 0, function* () {
-            const innerHTML = "<input @click=\"{{handleClick()}}\">";
+        });
+        test("get the next attribute event binding", async () => {
+            const innerHTML = "<input @click=\"{handleClick()}\">";
             const templateResult = getNextBehavior(innerHTML);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("dataBinding");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.subtype).toEqual("attribute");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.aspect).toEqual("@");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.bindingType).toEqual("client");
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingStartIndex).toEqual(15);
-            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingEndIndex).toEqual(17);
-            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingStartIndex).toEqual(30);
-            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingEndIndex).toEqual(32);
-        }));
-    }));
-    test.describe("templates", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("when directive", () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingEndIndex).toEqual(16);
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingStartIndex).toEqual(29);
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingEndIndex).toEqual(30);
+        });
+        test("skip single-brace content bindings (e.g. CSS braces)", async () => {
+            const innerHTML = "<style>.foo { color: red }</style>";
+            const templateResult = getNextBehavior(innerHTML);
+            expect(templateResult).toBeNull();
+        });
+        test("skip single-brace non-event, non-property attribute bindings", async () => {
+            const innerHTML1 = "<input type=\"{type}\">";
+            const templateResult1 = getNextBehavior(innerHTML1);
+            expect(templateResult1).toBeNull();
+            const innerHTML2 = "<input ?disabled=\"{disabled}\">";
+            const templateResult2 = getNextBehavior(innerHTML2);
+            expect(templateResult2).toBeNull();
+        });
+        test("find double-brace binding after skipped single-brace content", async () => {
+            const innerHTML = "<style>.foo { color: red } .bar { color: blue }</style><span>{{name}}</span>";
+            const templateResult = getNextBehavior(innerHTML);
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("dataBinding");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.subtype).toEqual("content");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.bindingType).toEqual("default");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingStartIndex).toEqual(61);
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingStartIndex).toEqual(67);
+        });
+        test("find event binding after skipped single-brace content", async () => {
+            const innerHTML = "<style>.foo { color: red }</style><button @click=\"{handler()}\">";
+            const templateResult = getNextBehavior(innerHTML);
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("dataBinding");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.subtype).toEqual("attribute");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.aspect).toEqual("@");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.bindingType).toEqual("client");
+        });
+        test("find property binding after skipped single-brace content", async () => {
+            const innerHTML = "<style>.foo { color: red } .bar { color: blue }</style><button :value=\"{someValue}\">";
+            const templateResult = getNextBehavior(innerHTML);
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("dataBinding");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.subtype).toEqual("attribute");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.aspect).toEqual(":");
+            expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.bindingType).toEqual("client");
+        });
+        test("ensure if there are expected missing {} this does not cause parsing issues", async () => {
+            const innerHTML = "<f-when value=\"missing\">";
+            expect(getNextBehavior(innerHTML)).toBeTruthy();
+        });
+    });
+    test.describe("templates", async () => {
+        test("when directive", async () => {
             const innerHTML = "<f-when value=\"{{show}}\">Hello world</f-when>";
             const templateResult = getNextBehavior(innerHTML);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("templateDirective");
@@ -47,8 +92,8 @@ test.describe("utilities", () => __awaiter(void 0, void 0, void 0, function* ()
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingTagEndIndex).toEqual(25);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingTagStartIndex).toEqual(36);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingTagEndIndex).toEqual(45);
-        }));
-        test("when directive with content", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        test("when directive with content", async () => {
             const innerHTML = "Hello pluto<f-when value=\"{{show}}\">Hello world</f-when>";
             const templateResult = getNextBehavior(innerHTML);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("templateDirective");
@@ -56,8 +101,8 @@ test.describe("utilities", () => __awaiter(void 0, void 0, void 0, function* ()
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingTagEndIndex).toEqual(36);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingTagStartIndex).toEqual(47);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingTagEndIndex).toEqual(56);
-        }));
-        test("when directive with binding", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        test("when directive with binding", async () => {
             const innerHTML = "<f-when value=\"{{show}}\">{{text}}</f-when>";
             const templateResult = getNextBehavior(innerHTML);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.type).toEqual("templateDirective");
@@ -65,96 +110,480 @@ test.describe("utilities", () => __awaiter(void 0, void 0, void 0, function* ()
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.openingTagEndIndex).toEqual(25);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingTagStartIndex).toEqual(33);
             expect(templateResult === null || templateResult === void 0 ? void 0 : templateResult.closingTagEndIndex).toEqual(42);
-        }));
-    }));
-    test.describe("attributes", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("children directive", () => __awaiter(void 0, void 0, void 0, function* () {
-            const innerHTML = "<ul f-children=\"{{list}}\"></ul>";
+        });
+    });
+    test.describe("attributes", async () => {
+        test("children directive", async () => {
+            const innerHTML = "<ul f-children=\"{list}\"></ul>";
             const result = getNextBehavior(innerHTML);
             expect(result === null || result === void 0 ? void 0 : result.type).toEqual("dataBinding");
             expect(result === null || result === void 0 ? void 0 : result.subtype).toEqual("attributeDirective");
             expect(result === null || result === void 0 ? void 0 : result.name).toEqual("children");
+            expect(result === null || result === void 0 ? void 0 : result.bindingType).toEqual("client");
             expect(result === null || result === void 0 ? void 0 : result.openingStartIndex).toEqual(16);
-            expect(result === null || result === void 0 ? void 0 : result.openingEndIndex).toEqual(18);
-            expect(result === null || result === void 0 ? void 0 : result.closingStartIndex).toEqual(22);
-            expect(result === null || result === void 0 ? void 0 : result.closingEndIndex).toEqual(24);
-        }));
-        test("slotted directive", () => __awaiter(void 0, void 0, void 0, function* () {
-            const innerHTML = "<slot f-slotted=\"{{slottedNodes}}\"></slot>";
+            expect(result === null || result === void 0 ? void 0 : result.openingEndIndex).toEqual(17);
+            expect(result === null || result === void 0 ? void 0 : result.closingStartIndex).toEqual(21);
+            expect(result === null || result === void 0 ? void 0 : result.closingEndIndex).toEqual(22);
+        });
+        test("slotted directive", async () => {
+            const innerHTML = "<slot f-slotted=\"{slottedNodes}\"></slot>";
             const result = getNextBehavior(innerHTML);
             expect(result === null || result === void 0 ? void 0 : result.type).toEqual("dataBinding");
             expect(result === null || result === void 0 ? void 0 : result.subtype).toEqual("attributeDirective");
             expect(result === null || result === void 0 ? void 0 : result.name).toEqual("slotted");
+            expect(result === null || result === void 0 ? void 0 : result.bindingType).toEqual("client");
             expect(result === null || result === void 0 ? void 0 : result.openingStartIndex).toEqual(17);
-            expect(result === null || result === void 0 ? void 0 : result.openingEndIndex).toEqual(19);
-            expect(result === null || result === void 0 ? void 0 : result.closingStartIndex).toEqual(31);
-            expect(result === null || result === void 0 ? void 0 : result.closingEndIndex).toEqual(33);
-        }));
-        test("ref directive", () => __awaiter(void 0, void 0, void 0, function* () {
-            const innerHTML = "<video f-ref=\"{{video}}\"></video>";
+            expect(result === null || result === void 0 ? void 0 : result.openingEndIndex).toEqual(18);
+            expect(result === null || result === void 0 ? void 0 : result.closingStartIndex).toEqual(30);
+            expect(result === null || result === void 0 ? void 0 : result.closingEndIndex).toEqual(31);
+        });
+        test("ref directive", async () => {
+            const innerHTML = "<video f-ref=\"{video}\"></video>";
             const result = getNextBehavior(innerHTML);
             expect(result === null || result === void 0 ? void 0 : result.type).toEqual("dataBinding");
             expect(result === null || result === void 0 ? void 0 : result.subtype).toEqual("attributeDirective");
             expect(result === null || result === void 0 ? void 0 : result.name).toEqual("ref");
+            expect(result === null || result === void 0 ? void 0 : result.bindingType).toEqual("client");
             expect(result === null || result === void 0 ? void 0 : result.openingStartIndex).toEqual(14);
-            expect(result === null || result === void 0 ? void 0 : result.openingEndIndex).toEqual(16);
-            expect(result === null || result === void 0 ? void 0 : result.closingStartIndex).toEqual(21);
-            expect(result === null || result === void 0 ? void 0 : result.closingEndIndex).toEqual(23);
-        }));
-    }));
-    test.describe("partials", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("get a single partial", () => __awaiter(void 0, void 0, void 0, function* () {
-            const partialContent = "{{text}}";
-            const partial = `<f-partial id="foo">${partialContent}</f-partial>`;
-            const allPartials = getAllPartials(partial);
-            expect(allPartials.foo.innerHTML).toEqual(partialContent);
-            expect(allPartials.foo.startIndex).toEqual(20);
-            expect(allPartials.foo.endIndex).toEqual(28);
-        }));
-        test("get multiple partials", () => __awaiter(void 0, void 0, void 0, function* () {
-            const partial1Content = "{{text}}";
-            const partial2Content = "{{othertext}}";
-            const partial1 = `<f-partial id="foo">${partial1Content}</f-partial>`;
-            const partial2 = `<f-partial id="foobar">${partial2Content}</f-partial>`;
-            const allPartials = getAllPartials(`${partial1}${partial2}`);
-            expect(allPartials.foo.innerHTML).toEqual(partial1Content);
-            expect(allPartials.foo.startIndex).toEqual(20);
-            expect(allPartials.foo.endIndex).toEqual(28);
-            expect(allPartials.foobar.innerHTML).toEqual(partial2Content);
-            expect(allPartials.foobar.startIndex).toEqual(63);
-            expect(allPartials.foobar.endIndex).toEqual(76);
-        }));
-    }));
-    test.describe("getIndexOfNextMatchingTag", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("should resolve a single tag", () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(result === null || result === void 0 ? void 0 : result.openingEndIndex).toEqual(15);
+            expect(result === null || result === void 0 ? void 0 : result.closingStartIndex).toEqual(20);
+            expect(result === null || result === void 0 ? void 0 : result.closingEndIndex).toEqual(21);
+        });
+    });
+    test.describe("getIndexOfNextMatchingTag", async () => {
+        test("should resolve a single tag", async () => {
             const index = getIndexOfNextMatchingTag(`<div>Hello world</div>`, `<div`, `</div>`, 0);
             expect(index).toEqual(16);
-        }));
-        test("should resolve when there is a nested tag", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        test("should resolve when there is a nested tag", async () => {
             const index = getIndexOfNextMatchingTag(`<div><div>Hello world</div></div>`, `<div`, `</div>`, 0);
             expect(index).toEqual(27);
-        }));
-        test("should get adjacent tags", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        test("should get adjacent tags", async () => {
             const index = getIndexOfNextMatchingTag(`<div>Hello world</div><div>Hello pluto</div>`, `<div`, `</div>`, 0);
             expect(index).toEqual(16);
-        }));
-        test("should add an offset for content before the tag", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        test("should add an offset for content before the tag", async () => {
             const index = getIndexOfNextMatchingTag(`<div>Hello world</div>`, `<div`, `</div>`, 23);
             expect(index).toEqual(39);
-        }));
-    }));
-    test.describe("pathResolver", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("should resolve a path with no nesting", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(pathResolver("foo")({ foo: "bar" })).toEqual("bar");
-        }));
-        test("should resolve a path with nesting", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(pathResolver("foo.bar.bat")({ foo: { bar: { bat: "baz" } } })).toEqual("baz");
-        }));
-        test("should resolve a path with no nesting and self reference", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(pathResolver("foo", true)("bar")).toEqual("bar");
-        }));
-        test("should resolve a path with nesting and self reference", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(pathResolver("foo.bar.bat", true)({ bar: { bat: "baz" } })).toEqual("baz");
-        }));
-    }));
-}));
+        });
+    });
+    test.describe("pathResolver", async () => {
+        test("should resolve a path with no nesting", async () => {
+            expect(pathResolver("foo", null, 0, {})({ foo: "bar" }, {})).toEqual("bar");
+        });
+        test("should resolve a path with nesting", async () => {
+            expect(pathResolver("foo.bar.bat", null, 0, {})({ foo: { bar: { bat: "baz" } } }, {})).toEqual("baz");
+        });
+        test("should resolve a path with no nesting and self reference", async () => {
+            expect(pathResolver("foo", "foo", 0, {})("bar", {})).toEqual("bar");
+        });
+        test("should resolve a path with nesting and self reference", async () => {
+            expect(pathResolver("foo.bar.bat", "foo", 0, {})({ bar: { bat: "baz" } }, {})).toEqual("baz");
+        });
+        test("should resolve a path with context", async () => {
+            expect(pathResolver("foo", "parent", 1, {})({}, { parent: { foo: "bar" } })).toEqual("bar");
+        });
+    });
+    test.describe("transformInnerHTML", async () => {
+        test("should resolve a single unescaped data binding", async () => {
+            expect(transformInnerHTML(`{{{html}}}`)).toEqual(`<div :innerHTML="{{html}}"></div>`);
+        });
+        test("should resolve multiple unescaped data bindings", async () => {
+            expect(transformInnerHTML(`{{{foo}}}{{{bar}}}`)).toEqual(`<div :innerHTML="{{foo}}"></div><div :innerHTML="{{bar}}"></div>`);
+        });
+        test("should resolve an unescaped data bindings in a mix of other data content bindings", async () => {
+            expect(transformInnerHTML(`{{text1}}{{{foo}}}{{text2}}{{{bar}}}{{text3}}`)).toEqual(`{{text1}}<div :innerHTML="{{foo}}"></div>{{text2}}<div :innerHTML="{{bar}}"></div>{{text3}}`);
+        });
+        test("should resolve default data bindings in sequence", async () => {
+            expect(transformInnerHTML(`{{text1}}{{text2}}`)).toEqual(`{{text1}}{{text2}}`);
+        });
+        test("should resolve an unescaped data bindings in a mix of other data attribute bindings and nesting", async () => {
+            expect(transformInnerHTML(`<div data-foo="{{text1}}">{{{foo}}}</div><div data-bar="{{text2}}"></div>{{{bar}}}<div data-bat="{{text3}}"></div>`)).toEqual(`<div data-foo="{{text1}}"><div :innerHTML="{{foo}}"></div></div><div data-bar="{{text2}}"></div><div :innerHTML="{{bar}}"></div><div data-bat="{{text3}}"></div>`);
+        });
+        test("should resolve a non-data and non-attribute bindings", async () => {
+            expect(transformInnerHTML(`<button @click="{handleNoArgsClick()}">No arguments</button>`)).toEqual(`<button @click="{handleNoArgsClick()}">No arguments</button>`);
+        });
+    });
+    test.describe("getExpressionChain", async () => {
+        test("should resolve a truthy value", async () => {
+            expect(getExpressionChain("foo")).toEqual({
+                expression: {
+                    operator: "access",
+                    left: "foo",
+                    leftIsValue: false,
+                    right: null,
+                    rightIsValue: null,
+                }
+            });
+        });
+        test("should resolve a falsy value", async () => {
+            expect(getExpressionChain("!foo")).toEqual({
+                expression: {
+                    operator: "!",
+                    left: "foo",
+                    leftIsValue: false,
+                    right: null,
+                    rightIsValue: null,
+                }
+            });
+        });
+        test("should resolve a path not equal to string value", async () => {
+            expect(getExpressionChain("foo != 'test'")).toEqual({
+                expression: {
+                    operator: "!=",
+                    left: "foo",
+                    leftIsValue: false,
+                    right: "test",
+                    rightIsValue: true,
+                }
+            });
+        });
+        test("should resolve a path not equal to boolean value", async () => {
+            expect(getExpressionChain("foo != false")).toEqual({
+                expression: {
+                    operator: "!=",
+                    left: "foo",
+                    leftIsValue: false,
+                    right: false,
+                    rightIsValue: true,
+                }
+            });
+        });
+        test("should resolve a path not equal to numerical value", async () => {
+            expect(getExpressionChain("foo != 5")).toEqual({
+                expression: {
+                    operator: "!=",
+                    left: "foo",
+                    leftIsValue: false,
+                    right: 5,
+                    rightIsValue: true,
+                }
+            });
+        });
+        test("should resolve chained expressions", async () => {
+            expect(getExpressionChain("foo != 'bat' && bar == 'baz'")).toEqual({
+                expression: {
+                    operator: "!=",
+                    left: "foo",
+                    leftIsValue: false,
+                    right: "bat",
+                    rightIsValue: true,
+                },
+                next: {
+                    operator: "&&",
+                    expression: {
+                        operator: "==",
+                        left: "bar",
+                        leftIsValue: false,
+                        right: "baz",
+                        rightIsValue: true,
+                    }
+                }
+            });
+            expect(getExpressionChain("foo && bar")).toEqual({
+                expression: {
+                    operator: "access",
+                    left: "foo",
+                    leftIsValue: false,
+                    right: null,
+                    rightIsValue: null,
+                },
+                next: {
+                    operator: "&&",
+                    expression: {
+                        operator: "access",
+                        left: "bar",
+                        leftIsValue: false,
+                        right: null,
+                        rightIsValue: null,
+                    }
+                }
+            });
+        });
+    });
+    test.describe("extractPathsFromChainedExpression", async () => {
+        test("should extract paths from simple access expression", async () => {
+            const expressionChain = getExpressionChain("user");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(1);
+            expect(paths.has("user")).toBe(true);
+        });
+        test("should extract paths from dot notation expression", async () => {
+            const expressionChain = getExpressionChain("user.name");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(1);
+            expect(paths.has("user.name")).toBe(true);
+        });
+        test("should extract paths from comparison with literal values", async () => {
+            const expressionChain = getExpressionChain("user.age > 18");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(1);
+            expect(paths.has("user.age")).toBe(true);
+        });
+        test("should extract paths from comparison between two properties", async () => {
+            const expressionChain = getExpressionChain("user.age >= admin.minAge");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(2);
+            expect(paths.has("user.age")).toBe(true);
+            expect(paths.has("admin.minAge")).toBe(true);
+        });
+        test("should extract paths from chained AND expressions", async () => {
+            const expressionChain = getExpressionChain("isActive && user.name");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(2);
+            expect(paths.has("isActive")).toBe(true);
+            expect(paths.has("user.name")).toBe(true);
+        });
+        test("should extract paths from chained OR expressions", async () => {
+            const expressionChain = getExpressionChain("user.isAdmin || permissions.canEdit");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(2);
+            expect(paths.has("user.isAdmin")).toBe(true);
+            expect(paths.has("permissions.canEdit")).toBe(true);
+        });
+        test("should extract paths from complex chained expressions", async () => {
+            const expressionChain = getExpressionChain("user.age > 18 && user.status == 'active' || admin.override");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(3);
+            expect(paths.has("user.age")).toBe(true);
+            expect(paths.has("user.status")).toBe(true);
+            expect(paths.has("admin.override")).toBe(true);
+        });
+        test("should extract paths from NOT expressions", async () => {
+            const expressionChain = getExpressionChain("!user.isDisabled");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(1);
+            expect(paths.has("user.isDisabled")).toBe(true);
+        });
+        test("should handle expressions with only literal values", async () => {
+            const expressionChain = getExpressionChain("5 > 3");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(0);
+        });
+        test("should handle mixed literal and property expressions", async () => {
+            const expressionChain = getExpressionChain("count > 0 && status == 'ready'");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(2);
+            expect(paths.has("count")).toBe(true);
+            expect(paths.has("status")).toBe(true);
+        });
+        test("should deduplicate identical paths", async () => {
+            const expressionChain = getExpressionChain("user.name && user.name != 'anonymous'");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(1);
+            expect(paths.has("user.name")).toBe(true);
+        });
+        test("should handle HTML entity operators", async () => {
+            const expressionChain = getExpressionChain("isValid &amp;&amp; data.ready");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(2);
+            expect(paths.has("isValid")).toBe(true);
+            expect(paths.has("data.ready")).toBe(true);
+        });
+        test("should handle deeply nested property paths", async () => {
+            const expressionChain = getExpressionChain("app.user.profile.settings.theme");
+            expect(expressionChain).toBeDefined();
+            const paths = extractPathsFromChainedExpression(expressionChain);
+            expect(paths.size).toEqual(1);
+            expect(paths.has("app.user.profile.settings.theme")).toBe(true);
+        });
+    });
+    test.describe("resolveWhen - default case truthiness evaluation", async () => {
+        // Helper to create a basic schema for testing
+        const createTestSchema = (rootPropertyName, propertyName) => {
+            const schema = new Schema("test-element");
+            schema.addPath({
+                rootPropertyName,
+                pathConfig: {
+                    type: "access",
+                    path: propertyName,
+                    currentContext: null,
+                    parentContext: null,
+                },
+                childrenMap: null,
+            });
+            return schema;
+        };
+        test("should evaluate boolean true as truthy", async () => {
+            const schema = createTestSchema("testData", "boolTrue");
+            const expression = getExpressionChain("boolTrue");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ boolTrue: true }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate boolean false as falsy", async () => {
+            const schema = createTestSchema("testData", "boolFalse");
+            const expression = getExpressionChain("boolFalse");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ boolFalse: false }, null);
+            expect(result).toBe(false);
+        });
+        test("should evaluate number 0 as falsy", async () => {
+            const schema = createTestSchema("testData", "numberZero");
+            const expression = getExpressionChain("numberZero");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ numberZero: 0 }, null);
+            expect(result).toBe(false);
+        });
+        test("should evaluate positive number as truthy", async () => {
+            const schema = createTestSchema("testData", "numberPositive");
+            const expression = getExpressionChain("numberPositive");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ numberPositive: 42 }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate negative number as truthy", async () => {
+            const schema = createTestSchema("testData", "numberNegative");
+            const expression = getExpressionChain("numberNegative");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ numberNegative: -5 }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate empty string as falsy", async () => {
+            const schema = createTestSchema("testData", "stringEmpty");
+            const expression = getExpressionChain("stringEmpty");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ stringEmpty: "" }, null);
+            expect(result).toBe(false);
+        });
+        test("should evaluate non-empty string as truthy", async () => {
+            const schema = createTestSchema("testData", "stringNonEmpty");
+            const expression = getExpressionChain("stringNonEmpty");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ stringNonEmpty: "hello" }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate null as falsy", async () => {
+            const schema = createTestSchema("testData", "objectNull");
+            const expression = getExpressionChain("objectNull");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ objectNull: null }, null);
+            expect(result).toBe(false);
+        });
+        test("should evaluate undefined as falsy", async () => {
+            const schema = createTestSchema("testData", "undefinedProp");
+            const expression = getExpressionChain("undefinedProp");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ undefinedProp: undefined }, null);
+            expect(result).toBe(false);
+        });
+        test("should evaluate non-null object as truthy", async () => {
+            const schema = createTestSchema("testData", "objectNonNull");
+            const expression = getExpressionChain("objectNonNull");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ objectNonNull: { foo: "bar" } }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate empty array as truthy", async () => {
+            const schema = createTestSchema("testData", "arrayEmpty");
+            const expression = getExpressionChain("arrayEmpty");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ arrayEmpty: [] }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate non-empty array as truthy", async () => {
+            const schema = createTestSchema("testData", "arrayNonEmpty");
+            const expression = getExpressionChain("arrayNonEmpty");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ arrayNonEmpty: [1, 2, 3] }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate string with only whitespace as truthy", async () => {
+            const schema = createTestSchema("testData", "stringWhitespace");
+            const expression = getExpressionChain("stringWhitespace");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ stringWhitespace: "   " }, null);
+            expect(result).toBe(true);
+        });
+        test("should evaluate number NaN as truthy", async () => {
+            const schema = createTestSchema("testData", "numberNaN");
+            const expression = getExpressionChain("numberNaN");
+            const resolver = resolveWhen("testData", expression, null, 0, schema);
+            const result = resolver({ numberNaN: NaN }, null);
+            expect(result).toBe(true);
+        });
+    });
+    test.describe("getChildrenMap", async () => {
+        test("should get a ChildrenMap if an attribute is part of a custom element", async () => {
+            const childrenMap = getChildrenMap(`<template><my-element foo="`);
+            expect(childrenMap).not.toBeNull();
+            expect(childrenMap === null || childrenMap === void 0 ? void 0 : childrenMap.attributeName).toEqual("foo");
+            expect(childrenMap === null || childrenMap === void 0 ? void 0 : childrenMap.customElementName).toEqual("my-element");
+        });
+        test("should not get a ChildrenMap if an attribute is part of a non-custom element", async () => {
+            const childrenMap = getChildrenMap(`<template><button foo="`);
+            expect(childrenMap).toBeNull();
+        });
+        test("should remove any aspected attributes from an attribute name", async () => {
+            const childrenMap = getChildrenMap(`<template><my-element :foo="`);
+            expect(childrenMap).not.toBeNull();
+            expect(childrenMap === null || childrenMap === void 0 ? void 0 : childrenMap.attributeName).toEqual("foo");
+            expect(childrenMap === null || childrenMap === void 0 ? void 0 : childrenMap.customElementName).toEqual("my-element");
+        });
+        test("should not get a ChildreMap if the previous string indicates the binding was not an attribute", async () => {
+            const childrenMap = getChildrenMap(`<template><my-element>`);
+            expect(childrenMap).toBeNull();
+        });
+        test("should get a ChildrenMap if there are multiple attributes are listed before this attribute", async () => {
+            const childrenMap = getChildrenMap(`<template><my-element foo="" bar="" bat="`);
+            expect(childrenMap).not.toBeNull();
+            expect(childrenMap === null || childrenMap === void 0 ? void 0 : childrenMap.attributeName).toEqual("bat");
+            expect(childrenMap === null || childrenMap === void 0 ? void 0 : childrenMap.customElementName).toEqual("my-element");
+        });
+    });
+    test.describe("schema functions", async () => {
+        test.describe("findDef", async () => {
+            test("should resolve from the root of a schema", async () => {
+                expect(findDef({
+                    [refPropertyName]: "#/$defs/MyType"
+                })).toEqual("MyType");
+            });
+            test("should resolve as null from an anyOf array containing a reference to another component", async () => {
+                expect(findDef({
+                    anyOf: [
+                        {
+                            [refPropertyName]: "https://fast.design/schemas/test-element/c.json"
+                        }
+                    ]
+                })).toEqual(null);
+            });
+            test("should resolve from an anyOf array containing a reference to a $def", async () => {
+                expect(findDef({
+                    anyOf: [
+                        {
+                            [refPropertyName]: "#/$defs/MyType"
+                        }
+                    ]
+                })).toEqual("MyType");
+            });
+            test("should resolve from an anyOf array containing a reference to another component and a reference to a $def", async () => {
+                expect(findDef({
+                    anyOf: [
+                        {
+                            [refPropertyName]: "https://fast.design/schemas/test-element/c.json"
+                        },
+                        {
+                            [refPropertyName]: "#/$defs/MyType"
+                        }
+                    ]
+                })).toEqual("MyType");
+            });
+            test("should resolve as null if not found", async () => {
+                expect(findDef({})).toEqual(null);
+            });
+        });
+    });
+});