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

package/dist/esm/components/utilities.js

@@ -1,4 +1,5 @@
 import { Observable } from "@microsoft/fast-element/observable.js";
+import { defsPropertyName, refPropertyName, } from "./schema.js";
 const openClientSideBinding = "{";
 const closeClientSideBinding = "}";
 const openContentBinding = "{{";
@@ -140,6 +141,11 @@ function getAttributeDirectiveDataBindingConfig(innerHTML, config) {
 function getContentDataBindingConfig(config) {
     return Object.assign(Object.assign({}, config), { subtype: "content" });
 }
+/**
+ * Finds the next data binding in innerHTML and determines its type and indices
+ * @param innerHTML - The innerHTML string to search for data bindings
+ * @returns NextDataBindingBehaviorConfig containing the binding type and start indices
+ */
 function getIndexAndBindingTypeOfNextDataBindingBehavior(innerHTML) {
     // {{{}}} binding
     const openingUnescapedStartIndex = innerHTML.indexOf(openUnescapedBinding);
@@ -214,36 +220,6 @@ export function getNextBehavior(innerHTML) {
     }
     return getNextDataBindingBehavior(innerHTML);
 }
-/**
- * Gets all the partials with their IDs
- * @param innerHTML - The innerHTML string to evaluate
- * @param offset - The index offset from the innerHTML
- * @param partials - The partials found
- * @returns {[key: string]: PartialTemplateConfig}
- */
-export function getAllPartials(innerHTML, offset = 0, partials = {}) {
-    const openingTag = `${openTagStart}partial`;
-    const openingTagStartIndex = innerHTML.indexOf(openingTag);
-    if (openingTagStartIndex >= 0) {
-        const openingTagStartSlice = innerHTML.slice(openingTagStartIndex);
-        const closingTag = `${closeTagStart}partial${tagEnd}`;
-        const closingTagLength = closingTag.length;
-        const matchingCloseTagIndex = getIndexOfNextMatchingTag(openingTagStartSlice, openingTag, closingTag, openingTagStartIndex) + closingTagLength;
-        const startId = openingTagStartIndex + ' id="'.length + openingTag.length;
-        const endId = innerHTML.slice(startId).indexOf('"') + startId;
-        const id = innerHTML.slice(startId, endId);
-        const openingTagEndIndex = openingTagStartSlice.indexOf(tagEnd) + 1 + openingTagStartIndex;
-        const closingTagStartIndex = matchingCloseTagIndex - closingTagLength;
-        partials[id] = {
-            innerHTML: innerHTML.slice(openingTagEndIndex, closingTagStartIndex),
-            startIndex: openingTagEndIndex + offset,
-            endIndex: closingTagStartIndex + offset,
-        };
-        offset += matchingCloseTagIndex;
-        return getAllPartials(innerHTML.slice(matchingCloseTagIndex), offset, partials);
-    }
-    return partials;
-}
 /**
  * Create a function to resolve a value from an object using a path with dot syntax.
  * e.g. "foo.bar"
@@ -251,30 +227,38 @@ export function getAllPartials(innerHTML, offset = 0, partials = {}) {
  * @param self - Where the first item in the path path refers to the item itself (used by repeat).
  * @returns A function to access the value from a given path.
  */
-export function pathResolver(path, self = false) {
-    let splitPath = [];
-    path.split("../").forEach((pathItem, index) => {
-        if (pathItem === "") {
-            splitPath.unshift("../");
+export function pathResolver(path, contextPath, level, rootSchema) {
+    var _a, _b;
+    let splitPath = path.split(".");
+    let levelCount = level;
+    let self = splitPath[0] === contextPath;
+    const parentContexts = [];
+    if (level > 0 &&
+        ((_b = (_a = rootSchema === null || rootSchema === void 0 ? void 0 : rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[contextPath]) === null || _b === void 0 ? void 0 : _b.$fast_context) ===
+            splitPath.at(-1)) {
+        self = true;
+    }
+    while (levelCount > 0 && !self) {
+        if (levelCount !== 1) {
+            parentContexts.push("parentContext");
         }
         else {
-            splitPath.push(...pathItem.split("."));
+            parentContexts.push("parent");
         }
-    });
-    splitPath = splitPath.map((pathItem, index) => {
-        if (pathItem === "../") {
-            if (splitPath[index + 1] === "../") {
-                return "parentContext";
-            }
-            return "parent";
-        }
-        return pathItem;
-    });
+        levelCount--;
+    }
+    splitPath = [...parentContexts, ...splitPath];
     return pathWithContextResolver(splitPath, self);
 }
+/**
+ * Creates a resolver function that can access properties from an object using a split path array
+ * @param splitPath - The dot syntax path split into an array of property names
+ * @param self - Whether the first item in the path refers to the item itself
+ * @returns A function that resolves the value from the given path on an accessible object
+ */
 function pathWithContextResolver(splitPath, self) {
-    const usesContext = splitPath[0] === "parent" || splitPath[0] === "parentContext";
-    if (self && !usesContext) {
+    const isInPreviousContext = splitPath[0] === "parent" || splitPath[0] === "parentContext";
+    if (self && !isInPreviousContext) {
         if (splitPath.length > 1) {
             splitPath = splitPath.slice(1);
         }
@@ -284,7 +268,7 @@ function pathWithContextResolver(splitPath, self) {
             };
         }
     }
-    if (usesContext) {
+    if (isInPreviousContext) {
         return (accessibleObject, context) => {
             return splitPath.reduce((previousAccessors, pathItem) => {
                 return previousAccessors === null || previousAccessors === void 0 ? void 0 : previousAccessors[pathItem];
@@ -297,40 +281,23 @@ function pathWithContextResolver(splitPath, self) {
         }, accessibleObject);
     };
 }
-export function bindingResolver(path, self = false, parentContext, type, observerMap, contextPath, level) {
-    // Cache path during template processing when ObserverMap is provided
-    if (observerMap) {
-        observerMap.cachePathWithContext({
-            path,
-            self,
-            parentContext,
-            contextPath,
-            type,
-            level,
-            rootPath: null,
-            context: null,
-        });
-    }
-    return pathResolver(path, self);
-}
-export function expressionResolver(self, expression, parentContext, level, observerMap) {
-    // Cache paths from expression during template processing when ObserverMap is provided
-    if (observerMap) {
-        const paths = extractPathsFromChainedExpression(expression);
-        paths.forEach(path => {
-            observerMap.cachePathWithContext({
-                path,
-                self,
+export function bindingResolver(rootPropertyName, path, parentContext, type, schema, currentContext, level) {
+    rootPropertyName = getRootPropertyName(rootPropertyName, path, currentContext, type);
+    if (type !== "event" && rootPropertyName !== null) {
+        schema.addPath({
+            pathConfig: {
+                type,
+                currentContext,
                 parentContext,
-                contextPath: null,
-                type: "access",
-                level,
-                rootPath: null,
-                context: null,
-            });
+                path,
+            },
+            rootPropertyName,
         });
     }
-    return (x, c) => resolveChainedExpression(x, c, self, expression);
+    return pathResolver(path, currentContext, level, schema.getSchema(rootPropertyName));
+}
+export function expressionResolver(rootPropertyName, expression, parentContext, level, schema) {
+    return (x, c) => resolveChainedExpression(x, c, level, parentContext || null, expression, schema.getSchema(rootPropertyName));
 }
 /**
  * Extracts all paths from a ChainedExpression, including nested expressions
@@ -358,7 +325,8 @@ export function extractPathsFromChainedExpression(chainedExpression) {
 }
 /**
  * Determine if the operand is a value (boolean, number, string) or an accessor.
- * @param operand
+ * @param operand - The string to evaluate as either a literal value or property accessor
+ * @returns An object containing the parsed value and whether it represents a literal value
  */
 function isOperandValue(operand) {
     try {
@@ -377,10 +345,10 @@ function isOperandValue(operand) {
     }
 }
 /**
- * Evaluates parts of an expression chain
- * @param parts Each part of an expression chain
- * @param operator The operator between expressions
- * @returns
+ * Evaluates parts of an expression chain and chains them with the specified operator
+ * @param parts - Each part of an expression chain to be evaluated
+ * @param operator - The logical operator used to chain the expression parts
+ * @returns A ChainedExpression object representing the linked expressions, or void if no valid expressions found
  */
 function evaluatePartsInExpressionChain(parts, operator) {
     // Process each part recursively and chain them with ||
@@ -441,6 +409,11 @@ export function getExpressionChain(value) {
     }
     return void 0;
 }
+/**
+ * Parses a binding value string into an Expression object
+ * @param value - The binding string value to parse (e.g., "!condition", "foo == bar", "property")
+ * @returns An Expression object containing the operator, operands, and whether operands are literal values
+ */
 function getExpression(value) {
     if (value[0] === "!") {
         const left = value.slice(1);
@@ -477,62 +450,77 @@ function getExpression(value) {
     };
 }
 /**
- * Resolve a single expression
- * @param x - The context
- * @param c - The parent context
- * @param self - Where the first item in the path path refers to the item itself (used by repeat).
- * @param expression - The expression being evaluated
- * @returns - A function resolving the binding for this expression
+ * Resolve a single expression by evaluating its operator and operands
+ * @param x - The current data context
+ * @param c - The parent context for accessing parent scope data
+ * @param level - The nesting level for context resolution
+ * @param contextPath - The current context path for property resolution
+ * @param expression - The expression object to evaluate
+ * @param rootSchema - The root JSON schema for data validation and navigation
+ * @returns The resolved value of the expression
  */
-function resolveExpression(x, c, self, expression) {
+function resolveExpression(x, c, level, contextPath, expression, rootSchema) {
     const { operator, left, right, rightIsValue } = expression;
     switch (operator) {
         case "!":
-            return !pathResolver(left, self)(x, c);
+            return !pathResolver(left, contextPath, level, rootSchema)(x, c);
         case "==":
-            return (pathResolver(left, self)(x, c) ==
-                (rightIsValue ? right : pathResolver(right, self)(x, c)));
+            return (pathResolver(left, contextPath, level, rootSchema)(x, c) ==
+                (rightIsValue
+                    ? right
+                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
         case "!=":
-            return (pathResolver(left, self)(x, c) !=
-                (rightIsValue ? right : pathResolver(right, self)(x, c)));
+            return (pathResolver(left, contextPath, level, rootSchema)(x, c) !=
+                (rightIsValue
+                    ? right
+                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
         case ">=":
-            return (pathResolver(left, self)(x, c) >=
-                (rightIsValue ? right : pathResolver(right, self)(x, c)));
+            return (pathResolver(left, contextPath, level, rootSchema)(x, c) >=
+                (rightIsValue
+                    ? right
+                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
         case ">":
-            return (pathResolver(left, self)(x, c) >
-                (rightIsValue ? right : pathResolver(right, self)(x, c)));
+            return (pathResolver(left, contextPath, level, rootSchema)(x, c) >
+                (rightIsValue
+                    ? right
+                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
         case "<=":
-            return (pathResolver(left, self)(x, c) <=
-                (rightIsValue ? right : pathResolver(right, self)(x, c)));
+            return (pathResolver(left, contextPath, level, rootSchema)(x, c) <=
+                (rightIsValue
+                    ? right
+                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
         case "<":
-            return (pathResolver(left, self)(x, c) <
-                (rightIsValue ? right : pathResolver(right, self)(x, c)));
+            return (pathResolver(left, contextPath, level, rootSchema)(x, c) <
+                (rightIsValue
+                    ? right
+                    : pathResolver(right, contextPath, level, rootSchema)(x, c)));
         default:
-            return pathResolver(left, self)(x, c);
+            return pathResolver(left, contextPath, level, rootSchema)(x, c);
     }
 }
 /**
- * Resolve a chained expression
- * @param x - The context
- * @param c - The parent context
- * @param self - Where the first item in the path path refers to the item itself (used by repeat).
- * @param expression - The expression being evaluated
- * @param next - The next expression to be chained
- * @returns - A resolved return value for a binding
+ * Resolve a chained expression by evaluating expressions linked with logical operators
+ * @param x - The current data context
+ * @param c - The parent context for accessing parent scope data
+ * @param level - The nesting level for context resolution
+ * @param contextPath - The current context path for property resolution
+ * @param expression - The chained expression object containing linked expressions
+ * @param rootSchema - The root JSON schema for data validation and navigation
+ * @returns The resolved boolean result of the chained expression
  */
-function resolveChainedExpression(x, c, self, expression) {
+function resolveChainedExpression(x, c, level, contextPath, expression, rootSchema) {
     if (expression.next) {
         switch (expression.next.operator) {
             case "&&":
             case "&amp;&amp;":
-                return (resolveExpression(x, c, self, expression.expression) &&
-                    resolveChainedExpression(x, c, self, expression.next));
+                return (resolveExpression(x, c, level, contextPath, expression.expression, rootSchema) &&
+                    resolveChainedExpression(x, c, level, contextPath, expression.next, rootSchema));
             case "||":
-                return (resolveExpression(x, c, self, expression.expression) ||
-                    resolveChainedExpression(x, c, self, expression.next));
+                return (resolveExpression(x, c, level, contextPath, expression.expression, rootSchema) ||
+                    resolveChainedExpression(x, c, level, contextPath, expression.next, rootSchema));
         }
     }
-    return resolveExpression(x, c, self, expression.expression);
+    return resolveExpression(x, c, level, contextPath, expression.expression, rootSchema);
 }
 /**
  * This is the transform utility for rationalizing declarative HTML syntax
@@ -568,44 +556,35 @@ export function transformInnerHTML(innerHTML, index = 0) {
  * @param self - Where the first item in the path path refers to the item itself (used by repeat).
  * @param chainedExpression - The chained expression which includes the expression and the next expression
  * if there is another in the chain
- * @param observerMap - Optional ObserverMap instance for caching paths during template processing
  * @returns - A binding that resolves the chained expression logic
  */
-export function resolveWhen(self, expression, parentContext, level, observerMap) {
-    const binding = expressionResolver(self, expression, parentContext, level, observerMap);
+export function resolveWhen(rootPropertyName, expression, parentContext, level, schema) {
+    const binding = expressionResolver(rootPropertyName, expression, parentContext, level, schema);
     return (x, c) => binding(x, c);
 }
 /**
- * Helper function to determine the data type of an object property
+ * Determines the data type of the provided data
+ * @param data - The data to analyze
+ * @returns "array" for arrays, "object" for non-null objects, "primitive" for other types
  */
-function getDataType(object) {
-    if (Array.isArray(object))
+function getDataType(data) {
+    if (Array.isArray(data))
         return "array";
-    if (typeof object === "object" && object !== null)
+    if (typeof data === "object" && data !== null)
         return "object";
     return "primitive";
 }
 /**
- * Get the next property
- * @param path The dot syntax data path
- * @returns The next property
+ * Assigns Observable properties to items in an array and sets up change notifications
+ * @param proxiedData - The array data to make observable
+ * @param schema - The schema defining the structure of array items
+ * @param rootSchema - The root schema for the entire data structure
+ * @returns The array with observable properties and change notifications
  */
-export function getNextProperty(path) {
-    return path.split(".")[0];
-}
-function sortByDeepestNestingItem(first, second) {
-    const firstRelativePathLength = first.length;
-    const secondRelativePathLength = second.length;
-    return firstRelativePathLength > secondRelativePathLength
-        ? -1
-        : secondRelativePathLength > firstRelativePathLength
-            ? 1
-            : 0;
-}
-function assignObservablesToArray(proxiedData, cachePath) {
+function assignObservablesToArray(proxiedData, schema, rootSchema) {
     const data = proxiedData.map((item) => {
         const originalItem = Object.assign({}, item);
-        assignProxyToItemsInArray(item, originalItem, cachePath);
+        assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
         return Object.assign(item, originalItem);
     });
     Observable.getNotifier(data).subscribe({
@@ -615,7 +594,7 @@ function assignObservablesToArray(proxiedData, cachePath) {
                     for (let i = arg.addedCount - 1; i >= 0; i--) {
                         const item = subject[arg.index + i];
                         const originalItem = Object.assign({}, item);
-                        assignProxyToItemsInArray(item, originalItem, cachePath);
+                        assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
                         return Object.assign(item, originalItem);
                     }
                 }
@@ -624,73 +603,104 @@ function assignObservablesToArray(proxiedData, cachePath) {
     });
     return data;
 }
-export function assignObservables(cachePath, data, target, rootProperty) {
+/**
+ * Extracts the definition name from a JSON Schema $ref property
+ * @param defName - The $ref string (e.g., "#/$defs/MyType")
+ * @returns The definition name (e.g., "MyType")
+ */
+function getDefFromRef(defName) {
+    const splitName = defName.split("/");
+    return splitName.at(-1);
+}
+/**
+ * Assign observables to data
+ * @param schema - The schema
+ * @param rootSchema - The root schema mapping to the root property
+ * @param data - The data
+ * @param target - The target custom element
+ * @param rootProperty - The root property
+ * @returns
+ */
+export function assignObservables(schema, rootSchema, data, target, rootProperty) {
+    var _a;
     const dataType = getDataType(data);
     let proxiedData = data;
     switch (dataType) {
         case "array": {
-            if (cachePath.type === "repeat") {
-                proxiedData = assignObservablesToArray(proxiedData, cachePath);
-            }
+            const context = getDefFromRef(schema[refPropertyName]);
+            proxiedData = assignObservablesToArray(proxiedData, (_a = rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[context], rootSchema);
             break;
         }
         case "object": {
-            if (cachePath.type === "default") {
-                const relativePaths = Object.values(cachePath.paths)
-                    .map((value) => {
-                    return value.relativePath.split(".").slice(1); // the first item is the root path
-                })
-                    .sort(sortByDeepestNestingItem);
-                for (const relativePath of relativePaths) {
-                    proxiedData = assignProxyToItemsInObject(relativePath, target, rootProperty, proxiedData, cachePath);
-                }
-            }
+            proxiedData = assignProxyToItemsInObject(target, rootProperty, proxiedData, schema, rootSchema);
             break;
         }
     }
     return proxiedData;
 }
-function assignProxyToItemsInArray(item, originalItem, cachePath) {
+/**
+ * Assign a proxy to items in an array
+ * @param item - The array item to proxy
+ * @param originalItem - The original array item
+ * @param schema - The schema mapping to the items in the array
+ * @param rootSchema - The root schema assigned to the root property
+ */
+function assignProxyToItemsInArray(item, originalItem, schema, rootSchema) {
     const itemProperties = Object.keys(item);
     itemProperties.forEach(key => {
         Observable.defineProperty(item, key);
-        const relativePaths = Object.values(cachePath.paths).filter(pathItem => {
-            if (pathItem.type === "access") {
-                return pathItem.relativePath.startsWith(`${cachePath.context}.${key}.`);
-            }
-            return false;
-        })
-            .map(value => {
-            return value.relativePath.split(".").slice(2); // the first item is the context, the next is the property
-        })
-            .sort(sortByDeepestNestingItem);
-        for (const relativePath of relativePaths) {
-            originalItem[key] = assignProxyToItemsInObject(relativePath, item, key, originalItem[key], cachePath);
+        if (originalItem[key] && schema && schema.properties) {
+            originalItem[key] = assignProxyToItemsInObject(item, key, originalItem[key], schema.properties[key], rootSchema);
         }
     });
 }
-function assignProxyToItemsInObject(paths, target, rootProperty, data, cachePath) {
+/**
+ * Assign a proxy to items in an object
+ * @param target - The target custom element
+ * @param rootProperty - The root property
+ * @param data - The data to proxy
+ * @param schema - The schema for the data
+ * @param rootSchema - The root schema for the root property
+ * @returns a Proxy
+ */
+function assignProxyToItemsInObject(target, rootProperty, data, schema, rootSchema) {
+    var _a;
     const type = getDataType(data);
     let proxiedData = data;
-    if (type === "object") {
+    if (type === "object" && (schema === null || schema === void 0 ? void 0 : schema.properties)) {
         // navigate through all items in the object
-        proxiedData[paths[0]] = assignProxyToItemsInObject(paths.slice(1), target, rootProperty, proxiedData[paths[0]], cachePath);
+        Object.keys(schema.properties).forEach(property => {
+            if (proxiedData[property] && schema && schema.properties) {
+                proxiedData[property] = assignProxyToItemsInObject(target, rootProperty, proxiedData[property], schema.properties[property], rootSchema);
+            }
+        });
         // assign a Proxy to the object
-        proxiedData = assignProxy(cachePath, target, rootProperty, data);
+        proxiedData = assignProxy(schema, rootSchema, target, rootProperty, data);
     }
     else if (type === "array") {
-        if (cachePath.type === "repeat") {
-            proxiedData = assignObservablesToArray(proxiedData, cachePath.paths[rootProperty]);
+        const context = getDefFromRef(schema.items[refPropertyName]);
+        const definition = (_a = rootSchema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[context];
+        if ((definition === null || definition === void 0 ? void 0 : definition.type) === "object") {
+            proxiedData = assignObservablesToArray(proxiedData, definition, rootSchema);
         }
     }
     return proxiedData;
 }
-export function assignProxy(cachePath, target, rootProperty, object) {
+/**
+ * Assign a proxy to an object
+ * @param schema - The current schema
+ * @param rootSchema - The root schema for the root property
+ * @param target - The target custom element
+ * @param rootProperty - The root property
+ * @param object - The object to assign the proxy to
+ * @returns Proxy object
+ */
+export function assignProxy(schema, rootSchema, target, rootProperty, object) {
     if (object.$isProxy === undefined) {
         // Create a proxy for the object that triggers Observable.notify on mutations
         return new Proxy(object, {
             set: (obj, prop, value) => {
-                obj[prop] = assignObservables(cachePath, value, target, rootProperty);
+                obj[prop] = assignObservables(schema, rootSchema, value, target, rootProperty);
                 // Trigger notification for property changes
                 Observable.notify(target, rootProperty);
                 return true;
@@ -714,3 +724,16 @@ export function assignProxy(cachePath, target, rootProperty, object) {
     }
     return object;
 }
+/**
+ * Get the root property name
+ * @param rootPropertyName - The root property
+ * @param path - The dot syntax path
+ * @param context - The context created by a repeat
+ * @param type - The type of path binding
+ * @returns
+ */
+export function getRootPropertyName(rootPropertyName, path, context, type) {
+    return (rootPropertyName === null || context === null) && type !== "event"
+        ? path.split(".")[0]
+        : rootPropertyName;
+}

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

@@ -1,6 +1,6 @@
 import { __awaiter } from "tslib";
 import { expect, test } from "@playwright/test";
-import { getNextBehavior, getAllPartials, getIndexOfNextMatchingTag, pathResolver, transformInnerHTML, getExpressionChain, extractPathsFromChainedExpression, } from "./utilities.js";
+import { getNextBehavior, getIndexOfNextMatchingTag, pathResolver, transformInnerHTML, getExpressionChain, extractPathsFromChainedExpression, } 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* () {
@@ -108,29 +108,6 @@ test.describe("utilities", () => __awaiter(void 0, void 0, void 0, function* ()
             expect(result === null || result === void 0 ? void 0 : result.closingEndIndex).toEqual(21);
         }));
     }));
-    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* () {
             const index = getIndexOfNextMatchingTag(`<div>Hello world</div>`, `<div`, `</div>`, 0);
@@ -151,19 +128,19 @@ test.describe("utilities", () => __awaiter(void 0, void 0, void 0, function* ()
     }));
     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");
+            expect(pathResolver("foo", null, 0, {})({ 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");
+            expect(pathResolver("foo.bar.bat", null, 0, {})({ 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");
+            expect(pathResolver("foo", "foo", 0, {})("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");
+            expect(pathResolver("foo.bar.bat", "foo", 0, {})({ bar: { bat: "baz" } }, {})).toEqual("baz");
         }));
         test("should resolve a path with context", () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(pathResolver("../foo")({}, { parent: { foo: "bar" } })).toEqual("bar");
+            expect(pathResolver("foo", "parent", 1, {})({}, { parent: { foo: "bar" } })).toEqual("bar");
         }));
     }));
     test.describe("transformInnerHTML", () => __awaiter(void 0, void 0, void 0, function* () {

package/dist/esm/fixtures/repeat/main.js

@@ -5,7 +5,7 @@ class TestElement extends FASTElement {
     constructor() {
         super(...arguments);
         this.list = ["Foo", "Bar"];
-        this.parent = "Bat";
+        this.item_parent = "Bat";
     }
 }
 __decorate([