@microsoft/fast-html 1.0.0-alpha.19 → 1.0.0-alpha.20

package/dist/esm/components/observer-map.spec.js

@@ -1,613 +1,19 @@
 import { __awaiter } from "tslib";
 import { expect, test } from "@playwright/test";
 import { ObserverMap } from "./observer-map.js";
+import { Schema } from "./schema.js";
 test.describe("ObserverMap", () => __awaiter(void 0, void 0, void 0, function* () {
     let observerMap;
+    let schema = new Schema("test-class");
     class TestClass {
     }
     test.beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         // Use TestClass.prototype so instances will have the observable properties
-        observerMap = new ObserverMap(TestClass.prototype);
+        observerMap = new ObserverMap(TestClass.prototype, schema);
     }));
     test("should create new instances", () => __awaiter(void 0, void 0, void 0, function* () {
-        const instance1 = new ObserverMap(TestClass.prototype);
-        const instance2 = new ObserverMap(TestClass.prototype);
+        const instance1 = new ObserverMap(TestClass.prototype, schema);
+        const instance2 = new ObserverMap(TestClass.prototype, schema);
         expect(instance1).not.toBe(instance2);
     }));
-    test.describe("should calculate an absolute path", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("when the level is 0 and no context path is provided", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(observerMap.getAbsolutePath({
-                path: "a",
-                self: false,
-                level: 0,
-                parentContext: null,
-                contextPath: null,
-                type: "access",
-                rootPath: null,
-                context: null,
-            })).toEqual("a");
-        }));
-        test("when the level is at 2 and the path is 2 levels up and no context path is provided", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(observerMap.getAbsolutePath({
-                path: "../../a",
-                self: false,
-                level: 2,
-                parentContext: null,
-                contextPath: null,
-                type: "access",
-                rootPath: null,
-                context: null,
-            })).toEqual("a");
-        }));
-        test("when the level is at 2 and the path is 1 level up with a multi-level of context path", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(observerMap.getAbsolutePath({
-                path: "../a",
-                self: false,
-                level: 2,
-                parentContext: null,
-                contextPath: "b.c.d",
-                type: "access",
-                rootPath: null,
-                context: null,
-            })).toEqual("b.c.a");
-        }));
-        test("when the level is at 2 and the path is 0 levels up with a multi-level context path", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(observerMap.getAbsolutePath({
-                path: "a",
-                self: false,
-                level: 2,
-                parentContext: null,
-                contextPath: "b.c.d",
-                type: "access",
-                rootPath: null,
-                context: null,
-            })).toEqual("b.a");
-        }));
-        test("when the level is at 2 and the path is 1 level up with a single level context path", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(observerMap.getAbsolutePath({
-                path: "../a",
-                self: false,
-                level: 2,
-                parentContext: null,
-                contextPath: "b",
-                type: "access",
-                rootPath: null,
-                context: null,
-            })).toEqual("a");
-        }));
-        test("when the level is 0 and the path is 0 a context has been provided and a repeat type", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(observerMap.getAbsolutePath({
-                path: "items",
-                self: false,
-                level: 0,
-                parentContext: null,
-                contextPath: "item",
-                type: "repeat",
-                rootPath: null,
-                context: null,
-            })).toEqual("items");
-        }));
-        test("when the item refers to itself", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(observerMap.getAbsolutePath({
-                path: "item.a",
-                self: true,
-                level: 1,
-                parentContext: null,
-                contextPath: "items",
-                type: "access",
-                rootPath: null,
-                context: null,
-            })).toEqual("items.__index__.a");
-        }));
-        test("when a parent context is given", () => __awaiter(void 0, void 0, void 0, function* () {
-            /**
-             * This should create a "users" context, which in turn should create an "items" context,
-             * these should have Symbol references to each other
-             */
-            observerMap.cachePathWithContext({
-                path: "users",
-                self: false,
-                parentContext: null,
-                contextPath: "user",
-                type: "repeat",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "items",
-                self: true,
-                parentContext: "user",
-                contextPath: "item",
-                type: "repeat",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.a",
-                self: true,
-                parentContext: "item",
-                contextPath: null,
-                type: "access",
-                level: 2,
-                rootPath: null,
-                context: null,
-            });
-            expect(observerMap.getAbsolutePath({
-                path: "item.a",
-                self: true,
-                level: 1,
-                parentContext: "user",
-                contextPath: "items",
-                type: "access",
-                rootPath: null,
-                context: null,
-            })).toEqual("users.__index__.items.__index__.a");
-        }));
-    }));
-    test.describe("should cache paths with contexts", () => __awaiter(void 0, void 0, void 0, function* () {
-        test("should cache a path", () => __awaiter(void 0, void 0, void 0, function* () {
-            observerMap.cachePathWithContext({
-                path: "a",
-                self: false,
-                parentContext: null,
-                contextPath: null,
-                type: "access",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            expect(cachedPathsWithContext["a"]).toBeDefined();
-            expect(cachedPathsWithContext["a"].type).toEqual("default");
-            expect(cachedPathsWithContext["a"].paths["a"]).toBeDefined();
-            expect(cachedPathsWithContext["a"].paths["a"].type).toEqual("access");
-            expect(cachedPathsWithContext["a"].paths["a"].relativePath).toEqual("a");
-            expect(cachedPathsWithContext["a"].paths["a"].absolutePath).toEqual("a");
-        }));
-        test("should cache a nested path", () => __awaiter(void 0, void 0, void 0, function* () {
-            observerMap.cachePathWithContext({
-                path: "a.b.c",
-                self: false,
-                parentContext: null,
-                contextPath: null,
-                type: "access",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            expect(cachedPathsWithContext["a"]).toBeDefined();
-            expect(cachedPathsWithContext["a"].type).toEqual("default");
-            expect(cachedPathsWithContext["a"].paths["a.b.c"]).toBeDefined();
-            expect(cachedPathsWithContext["a"].paths["a.b.c"].type).toEqual("access");
-            expect(cachedPathsWithContext["a"].paths["a.b.c"].relativePath).toEqual("a.b.c");
-            expect(cachedPathsWithContext["a"].paths["a.b.c"].absolutePath).toEqual("a.b.c");
-        }));
-        test("should cache multiple paths", () => __awaiter(void 0, void 0, void 0, function* () {
-            observerMap.cachePathWithContext({
-                path: "a.b.c",
-                self: false,
-                parentContext: null,
-                contextPath: null,
-                type: "access",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "a.b.d",
-                self: false,
-                parentContext: null,
-                contextPath: null,
-                type: "access",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            expect(cachedPathsWithContext["a"]).toBeDefined();
-            expect(cachedPathsWithContext["a"].type).toEqual("default");
-            expect(cachedPathsWithContext["a"].paths["a.b.c"]).toBeDefined();
-            expect(cachedPathsWithContext["a"].paths["a.b.c"].type).toEqual("access");
-            expect(cachedPathsWithContext["a"].paths["a.b.c"].relativePath).toEqual("a.b.c");
-            expect(cachedPathsWithContext["a"].paths["a.b.c"].absolutePath).toEqual("a.b.c");
-            expect(cachedPathsWithContext["a"].paths["a.b.d"]).toBeDefined();
-            expect(cachedPathsWithContext["a"].paths["a.b.d"].type).toEqual("access");
-            expect(cachedPathsWithContext["a"].paths["a.b.d"].relativePath).toEqual("a.b.d");
-            expect(cachedPathsWithContext["a"].paths["a.b.d"].absolutePath).toEqual("a.b.d");
-        }));
-        test("should cache a path with context", () => __awaiter(void 0, void 0, void 0, function* () {
-            /**
-             * Example:
-             * <f-repeat value="{{item in items}}">
-             *     {{item.a}}
-             * </f-repeat>
-             */
-            observerMap.cachePathWithContext({
-                path: "items",
-                self: false,
-                parentContext: null,
-                contextPath: "item",
-                type: "repeat",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.a",
-                self: true,
-                parentContext: "item",
-                contextPath: null,
-                type: "access",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            expect(cachedPathsWithContext["items"]).toBeDefined();
-            expect(cachedPathsWithContext["items"].type).toEqual("repeat");
-            expect(cachedPathsWithContext["items"].context).toEqual("item");
-            expect(cachedPathsWithContext["items"].paths["item.a"]).toBeDefined();
-            expect(cachedPathsWithContext["items"].paths["item.a"].type).toEqual("access");
-            expect(cachedPathsWithContext["items"].paths["item.a"].relativePath).toEqual("item.a");
-            expect(cachedPathsWithContext["items"].paths["item.a"].absolutePath).toEqual("items.__index__.a");
-        }));
-        test("should cache a nested path with context", () => __awaiter(void 0, void 0, void 0, function* () {
-            /**
-             * Example:
-             * <f-repeat value="{{item in root.items}}">
-             *     {{item.a}}
-             * </f-repeat>
-             */
-            observerMap.cachePathWithContext({
-                path: "root.items",
-                self: false,
-                parentContext: null,
-                contextPath: "item",
-                type: "repeat",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.a",
-                self: true,
-                parentContext: "item",
-                contextPath: null,
-                type: "access",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            expect(cachedPathsWithContext["root"]).toBeDefined();
-            expect(cachedPathsWithContext["root"].type).toEqual("default");
-            const root = cachedPathsWithContext["root"];
-            expect(root.paths["items"]).toBeDefined();
-            const items = root.paths["items"];
-            expect(items.type).toEqual("repeat");
-            expect(items.context).toEqual("item");
-            expect(items.paths["item.a"]).toBeDefined();
-            const itemA = items.paths["item.a"];
-            expect(itemA.type).toEqual("access");
-            expect(itemA.relativePath).toEqual("item.a");
-            expect(itemA.absolutePath).toEqual("root.items.__index__.a");
-        }));
-        test("should cache a nested repeat with nested path with context", () => __awaiter(void 0, void 0, void 0, function* () {
-            /**
-             * Example:
-             * <f-repeat value="{{item in root.items}}">
-             *     {{item.a}}
-             *     <f-repeat value="{{subitem in item.subitems}}">
-             *         {{subitem.title}}
-             *     </f-repeat>
-             * </f-repeat>
-             */
-            observerMap.cachePathWithContext({
-                path: "root.items",
-                self: false,
-                parentContext: null,
-                contextPath: "item",
-                type: "repeat",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.a",
-                self: true,
-                parentContext: "item",
-                contextPath: null,
-                type: "access",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.subitems",
-                self: true,
-                parentContext: "item",
-                contextPath: "subitem",
-                type: "repeat",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "subitem.title",
-                self: true,
-                parentContext: "subitem",
-                contextPath: null,
-                type: "access",
-                level: 2,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            expect(cachedPathsWithContext["root"]).toBeDefined();
-            expect(cachedPathsWithContext["root"].type).toEqual("default");
-            const root = cachedPathsWithContext["root"];
-            expect(root.paths["items"]).toBeDefined();
-            const items = root.paths["items"];
-            expect(items.type).toEqual("repeat");
-            expect(items.context).toEqual("item");
-            expect(items.paths["item.a"]).toBeDefined();
-            const itemA = items.paths["item.a"];
-            expect(itemA.type).toEqual("access");
-            expect(itemA.relativePath).toEqual("item.a");
-            expect(itemA.absolutePath).toEqual("root.items.__index__.a");
-            expect(items.paths["subitems"]).toBeDefined();
-            const subItems = items.paths["subitems"];
-            expect(subItems.type).toEqual("repeat");
-            expect(subItems.context).toEqual("subitem");
-            expect(subItems.paths["subitem.title"]).toBeDefined();
-            const subItemTitle = subItems.paths["subitem.title"];
-            expect(subItemTitle.type).toEqual("access");
-            expect(subItemTitle.relativePath).toEqual("subitem.title");
-            expect(subItemTitle.absolutePath).toEqual("root.items.__index__.subitems.__index__.title");
-        }));
-        test("should cache a multiple nested repeat with nested path with context", () => __awaiter(void 0, void 0, void 0, function* () {
-            /**
-             * Example:
-             * <f-repeat value="{{item in root.items}}">
-             *     {{item.a}}
-             *     <f-repeat value="{{user in item.users}}">
-             *         {{user.name}}
-             *         <f-repeat value="{{badge in user.badges}}">
-             *             {{badge}}
-             *         </f-repeat>
-             *     </f-repeat>
-             *     <f-repeat value="{{setting in item.settings}}">
-             *         {{setting.visibility}}
-             *     </f-repeat>
-             * </f-repeat>
-             */
-            observerMap.cachePathWithContext({
-                path: "root.items",
-                self: false,
-                parentContext: null,
-                contextPath: "item",
-                type: "repeat",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.a",
-                self: true,
-                parentContext: "item",
-                contextPath: null,
-                type: "access",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.users",
-                self: true,
-                parentContext: "item",
-                contextPath: "user",
-                type: "repeat",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "user.name",
-                self: true,
-                parentContext: "user",
-                contextPath: null,
-                type: "access",
-                level: 2,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "user.badges",
-                self: true,
-                parentContext: "user",
-                contextPath: "badge",
-                type: "repeat",
-                level: 2,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "badge",
-                self: true,
-                parentContext: "badge",
-                contextPath: null,
-                type: "access",
-                level: 3,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.settings",
-                self: true,
-                parentContext: "item",
-                contextPath: "setting",
-                type: "repeat",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "setting.visibility",
-                self: true,
-                parentContext: "setting",
-                contextPath: null,
-                type: "access",
-                level: 2,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            // Verify root structure
-            expect(cachedPathsWithContext["root"]).toBeDefined();
-            expect(cachedPathsWithContext["root"].type).toEqual("default");
-            const root = cachedPathsWithContext["root"];
-            // Verify items repeat structure
-            expect(root.paths["items"]).toBeDefined();
-            const items = root.paths["items"];
-            expect(items.type).toEqual("repeat");
-            expect(items.context).toEqual("item");
-            // Verify item.a access path
-            expect(items.paths["item.a"]).toBeDefined();
-            const itemA = items.paths["item.a"];
-            expect(itemA.type).toEqual("access");
-            expect(itemA.relativePath).toEqual("item.a");
-            expect(itemA.absolutePath).toEqual("root.items.__index__.a");
-            // Verify users repeat structure under items
-            expect(items.paths["users"]).toBeDefined();
-            const users = items.paths["users"];
-            expect(users.type).toEqual("repeat");
-            expect(users.context).toEqual("user");
-            // Verify user.name access path
-            expect(users.paths["user.name"]).toBeDefined();
-            const userName = users.paths["user.name"];
-            expect(userName.type).toEqual("access");
-            expect(userName.relativePath).toEqual("user.name");
-            expect(userName.absolutePath).toEqual("root.items.__index__.users.__index__.name");
-            // Verify badges repeat structure under users
-            expect(users.paths["badges"]).toBeDefined();
-            const badges = users.paths["badges"];
-            expect(badges.type).toEqual("repeat");
-            expect(badges.context).toEqual("badge");
-            // Verify badge access path
-            expect(badges.paths["badge"]).toBeDefined();
-            const badge = badges.paths["badge"];
-            expect(badge.type).toEqual("access");
-            expect(badge.relativePath).toEqual("badge");
-            expect(badge.absolutePath).toEqual("root.items.__index__.users.__index__.badges.__index__");
-            // Verify settings repeat structure under items (sibling to users)
-            expect(items.paths["settings"]).toBeDefined();
-            const settings = items.paths["settings"];
-            expect(settings.type).toEqual("repeat");
-            expect(settings.context).toEqual("setting");
-            // Verify setting.visibility access path
-            expect(settings.paths["setting.visibility"]).toBeDefined();
-            const settingVisibility = settings.paths["setting.visibility"];
-            expect(settingVisibility.type).toEqual("access");
-            expect(settingVisibility.relativePath).toEqual("setting.visibility");
-            expect(settingVisibility.absolutePath).toEqual("root.items.__index__.settings.__index__.visibility");
-        }));
-        test("should cache nested repeats with a path reference that belongs to the root parent context", () => __awaiter(void 0, void 0, void 0, function* () {
-            /**
-             * Example:
-             * <f-repeat value="{{item in root.items}}">
-             *     {{item.a}}
-             *     <f-repeat value="{{user in item.users}}">
-             *         {{user.name}}
-             *         <f-repeat value="{{badge in user.badges}}">
-             *             {{badge}}
-             *             {{../../../selectedId}}
-             *         </f-repeat>
-             *     </f-repeat>
-             * </f-repeat>
-             */
-            observerMap.cachePathWithContext({
-                path: "root.items",
-                self: false,
-                parentContext: null,
-                contextPath: "item",
-                type: "repeat",
-                level: 0,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.a",
-                self: true,
-                parentContext: "item",
-                contextPath: null,
-                type: "access",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "item.users",
-                self: true,
-                parentContext: "item",
-                contextPath: "user",
-                type: "repeat",
-                level: 1,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "user.name",
-                self: true,
-                parentContext: "user",
-                contextPath: null,
-                type: "access",
-                level: 2,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "user.badges",
-                self: true,
-                parentContext: "user",
-                contextPath: "badge",
-                type: "repeat",
-                level: 2,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "badge",
-                self: true,
-                parentContext: "badge",
-                contextPath: null,
-                type: "access",
-                level: 3,
-                rootPath: null,
-                context: null,
-            });
-            observerMap.cachePathWithContext({
-                path: "../../../selectedId",
-                self: true,
-                parentContext: "badge",
-                contextPath: null,
-                type: "access",
-                level: 3,
-                rootPath: null,
-                context: null,
-            });
-            const cachedPathsWithContext = observerMap.getCachedPathsWithContext();
-            // Verify root structure
-            expect(cachedPathsWithContext["root"]).toBeDefined();
-            expect(cachedPathsWithContext["root"].type).toEqual("default");
-            // Verify a nested item has been elevated to the root
-            expect(cachedPathsWithContext["selectedId"]).toBeDefined();
-            const selectedId = cachedPathsWithContext["selectedId"];
-            expect(selectedId.type).toEqual("access");
-            expect(selectedId.relativePath).toEqual("selectedId");
-            expect(selectedId.absolutePath).toEqual("selectedId");
-        }));
-    }));
 }));