@player-ui/check-path-plugin 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,220 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var view = require('@player-ui/view');
+var partialMatchRegistry = require('@player-ui/partial-match-registry');
+var dlv = require('dlv');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dlv__default = /*#__PURE__*/_interopDefaultLegacy(dlv);
+
+function createMatcher(match) {
+  if (typeof match === "string" || typeof match === "number") {
+    return partialMatchRegistry.createObjectMatcher({ type: match });
+  }
+  if (typeof match === "function") {
+    return match;
+  }
+  return partialMatchRegistry.createObjectMatcher(match);
+}
+function getParent(node, viewInfo) {
+  var _a;
+  let working = node;
+  while (working.parent && working.parent.type !== view.NodeType.Asset && working.parent.type !== view.NodeType.View) {
+    working = working.parent;
+  }
+  const { parent } = working;
+  if (parent && (parent.type === view.NodeType.Asset || parent.type === view.NodeType.View)) {
+    return (_a = viewInfo.resolver.getSourceNode(parent)) != null ? _a : parent;
+  }
+}
+class CheckPathPlugin {
+  constructor() {
+    this.name = "check-path";
+  }
+  apply(player) {
+    player.hooks.viewController.tap(this.name, (viewController) => {
+      viewController.hooks.view.tap(this.name, (view$1) => {
+        view$1.hooks.resolver.tap(this.name, (resolver) => {
+          const viewInfo = {
+            resolvedMap: new Map(),
+            assetIdMap: new Map(),
+            resolver
+          };
+          this.viewInfo = viewInfo;
+          resolver.hooks.afterResolve.tap(this.name, (value, node) => {
+            const sourceNode = resolver.getSourceNode(node);
+            if (sourceNode) {
+              viewInfo.resolvedMap.set(sourceNode, {
+                resolved: node,
+                value
+              });
+              if (node.type === view.NodeType.Asset || node.type === view.NodeType.View) {
+                const id = dlv__default["default"](value, "id");
+                if (id) {
+                  viewInfo.assetIdMap.set(id, node);
+                }
+              }
+            }
+            return value;
+          });
+        });
+      });
+    });
+  }
+  getParent(id, query) {
+    var _a;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode || !this.viewInfo) {
+      return void 0;
+    }
+    let potentialMatch = getParent(assetNode, this.viewInfo);
+    if (query === void 0) {
+      if (potentialMatch) {
+        const resolved = this.viewInfo.resolvedMap.get(potentialMatch);
+        return resolved == null ? void 0 : resolved.value;
+      }
+      return;
+    }
+    const queryArray = Array.isArray(query) ? [...query] : [query];
+    let parentQuery = queryArray.shift();
+    let depth = 0;
+    while (potentialMatch && parentQuery) {
+      if (depth++ >= 50) {
+        throw new Error("Recursion depth exceeded. Check for cycles in the AST graph");
+      }
+      const matcher = createMatcher(parentQuery);
+      const resolved = this.viewInfo.resolvedMap.get(potentialMatch);
+      if (resolved && matcher(resolved.value)) {
+        if (queryArray.length === 0) {
+          return resolved.value;
+        }
+        parentQuery = queryArray.shift();
+      }
+      potentialMatch = getParent(potentialMatch, this.viewInfo);
+    }
+    return void 0;
+  }
+  getParentProp(id) {
+    var _a, _b, _c, _d;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode || !this.viewInfo) {
+      return;
+    }
+    let working = assetNode;
+    let parent;
+    while (working) {
+      parent = (working == null ? void 0 : working.parent) && ((_b = this.viewInfo.resolvedMap.get(working.parent)) == null ? void 0 : _b.resolved);
+      if (parent && (parent.type === view.NodeType.Asset || parent.type === view.NodeType.View)) {
+        break;
+      }
+      working = working == null ? void 0 : working.parent;
+    }
+    if (parent && "children" in parent) {
+      const childProp = (_c = parent.children) == null ? void 0 : _c.find((child) => child.value === working);
+      return (_d = childProp == null ? void 0 : childProp.path) == null ? void 0 : _d[0];
+    }
+    return void 0;
+  }
+  hasParentContext(id, query) {
+    return Boolean(this.getParent(id, query));
+  }
+  findChildPath(node, query, includeSelfMatch = true) {
+    var _a, _b, _c, _d;
+    if (query.length === 0) {
+      return true;
+    }
+    const [first, ...rest] = query;
+    const matcher = createMatcher(first);
+    if (node.type === view.NodeType.Asset || node.type === view.NodeType.View) {
+      const resolved = (_a = this.viewInfo) == null ? void 0 : _a.resolvedMap.get(node);
+      const includesSelf = (_b = includeSelfMatch && resolved && matcher(resolved.value)) != null ? _b : false;
+      const childQuery = includesSelf ? rest : query;
+      if (childQuery.length === 0 && includesSelf) {
+        return true;
+      }
+      if (childQuery.length && (!node.children || node.children.length === 0)) {
+        return false;
+      }
+      if ((_c = node.children) == null ? void 0 : _c.some((childNode) => this.findChildPath(childNode.value, childQuery))) {
+        return true;
+      }
+    } else if (node.type === view.NodeType.MultiNode && node.values.some((childNode) => this.findChildPath(childNode, query))) {
+      return true;
+    } else if ("children" in node && ((_d = node.children) == null ? void 0 : _d.some((childNode) => this.findChildPath(childNode.value, query)))) {
+      return true;
+    }
+    return false;
+  }
+  hasChildContext(id, query) {
+    var _a;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    const queryArray = Array.isArray(query) ? [...query] : [query];
+    if (!assetNode) {
+      return false;
+    }
+    return this.findChildPath(assetNode, queryArray, false);
+  }
+  getAsset(id) {
+    var _a, _b, _c, _d;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode)
+      return;
+    const sourceNode = (_b = this.viewInfo) == null ? void 0 : _b.resolver.getSourceNode(assetNode);
+    if (!sourceNode)
+      return;
+    return (_d = (_c = this.viewInfo) == null ? void 0 : _c.resolvedMap.get(sourceNode)) == null ? void 0 : _d.value;
+  }
+  getPath(id, query) {
+    var _a, _b;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode || !this.viewInfo) {
+      return;
+    }
+    let path = [];
+    let queryArray = [];
+    if (query) {
+      queryArray = Array.isArray(query) ? [...query] : [query];
+    }
+    let parentQuery = queryArray.shift();
+    let working = assetNode;
+    const findWorkingChild = (parent) => {
+      var _a2;
+      return (_a2 = parent.children) == null ? void 0 : _a2.find((n) => n.value === working);
+    };
+    while (working !== void 0) {
+      const parent = (working == null ? void 0 : working.parent) && this.viewInfo.resolvedMap.get(working.parent);
+      const parentNode = parent == null ? void 0 : parent.resolved;
+      if (parentNode) {
+        if (parentNode.type === view.NodeType.MultiNode) {
+          const index = parentNode.values.indexOf(working);
+          if (index !== -1) {
+            const actualIndex = index - parentNode.values.slice(0, index).reduce((undefCount, next) => {
+              var _a2, _b2;
+              return ((_b2 = (_a2 = this.viewInfo) == null ? void 0 : _a2.resolvedMap.get(next)) == null ? void 0 : _b2.value) === void 0 ? undefCount + 1 : undefCount;
+            }, 0);
+            path = [actualIndex, ...path];
+          }
+        } else if ("children" in parentNode) {
+          const childProp = findWorkingChild(parentNode);
+          path = [...(_b = childProp == null ? void 0 : childProp.path) != null ? _b : [], ...path];
+        }
+      }
+      if (parentQuery) {
+        const matcher = createMatcher(parentQuery);
+        if (matcher(parent == null ? void 0 : parent.value)) {
+          parentQuery = queryArray.shift();
+          if (!parentQuery)
+            return path;
+        }
+      }
+      working = working.parent;
+    }
+    return queryArray.length === 0 ? path : void 0;
+  }
+}
+
+exports.CheckPathPlugin = CheckPathPlugin;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { PlayerPlugin, Player } from '@player-ui/player';
+import { Asset } from '@player-ui/types';
+
+declare type QueryFunction = (asset: Asset) => boolean;
+declare type Query = QueryFunction | string | object;
+/**
+ * The `check-path-plugin` enables developers to query segments of the view tree for contextual rendering or behavior.
+ * This is best suited to be referenced during the UI rendering phase, where one can make decisions about the rendering of an asset based on where it lies in the tree.
+ */
+declare class CheckPathPlugin implements PlayerPlugin {
+    name: string;
+    private viewInfo?;
+    apply(player: Player): void;
+    /**
+     * Starts at the asset with the given id, and walks backwards _up_ the tree until it finds a match for the parent
+     *
+     * @param id - The id of the asset to _start_ at
+     * @param query - A means of matching a parent asset
+     * @returns - The parent object if a match is found, else undefined
+     */
+    getParent(id: string, query?: Query | Array<Query>): Asset | undefined;
+    /**
+     * Returns the property that the asset resides on relative to it's parent
+     *
+     * @param id - The id of the asset to _start_ at
+     * @returns - The property name or undefined if no parent was found
+     */
+    getParentProp(id: string): string | number | undefined;
+    /**
+     * Given the starting node, check to verify that the supplied queries are relevant to the current asset's parents.
+     *
+     * @param id - The id of the asset to _start_ at
+     * @returns - true if the context applies, false if it doesn't
+     */
+    hasParentContext(id: string, query: Query | Array<Query>): boolean;
+    /** Search the node for any matching paths in the graph that match the query  */
+    private findChildPath;
+    /**
+     * Given the starting node, check to verify that the supplied queries are relevant to the current asset's children.
+     *
+     * @param id - The id of the asset to _start_ at
+     * @returns - true if the context applies, false if it doesn't
+     */
+    hasChildContext(id: string, query: Query | Array<Query>): boolean;
+    /** Get the asset represented by id */
+    getAsset(id: string): Asset | undefined;
+    /**
+     * Get the path of the asset in the view upto
+     * the asset that matches the query or to the view if no query is provided
+     */
+    getPath(id: string, query?: Query | Array<Query>): Array<string | number> | undefined;
+}
+
+export { CheckPathPlugin, Query, QueryFunction };

package/dist/index.esm.js

@@ -0,0 +1,212 @@
+import { NodeType } from '@player-ui/view';
+import { createObjectMatcher } from '@player-ui/partial-match-registry';
+import dlv from 'dlv';
+
+function createMatcher(match) {
+  if (typeof match === "string" || typeof match === "number") {
+    return createObjectMatcher({ type: match });
+  }
+  if (typeof match === "function") {
+    return match;
+  }
+  return createObjectMatcher(match);
+}
+function getParent(node, viewInfo) {
+  var _a;
+  let working = node;
+  while (working.parent && working.parent.type !== NodeType.Asset && working.parent.type !== NodeType.View) {
+    working = working.parent;
+  }
+  const { parent } = working;
+  if (parent && (parent.type === NodeType.Asset || parent.type === NodeType.View)) {
+    return (_a = viewInfo.resolver.getSourceNode(parent)) != null ? _a : parent;
+  }
+}
+class CheckPathPlugin {
+  constructor() {
+    this.name = "check-path";
+  }
+  apply(player) {
+    player.hooks.viewController.tap(this.name, (viewController) => {
+      viewController.hooks.view.tap(this.name, (view) => {
+        view.hooks.resolver.tap(this.name, (resolver) => {
+          const viewInfo = {
+            resolvedMap: new Map(),
+            assetIdMap: new Map(),
+            resolver
+          };
+          this.viewInfo = viewInfo;
+          resolver.hooks.afterResolve.tap(this.name, (value, node) => {
+            const sourceNode = resolver.getSourceNode(node);
+            if (sourceNode) {
+              viewInfo.resolvedMap.set(sourceNode, {
+                resolved: node,
+                value
+              });
+              if (node.type === NodeType.Asset || node.type === NodeType.View) {
+                const id = dlv(value, "id");
+                if (id) {
+                  viewInfo.assetIdMap.set(id, node);
+                }
+              }
+            }
+            return value;
+          });
+        });
+      });
+    });
+  }
+  getParent(id, query) {
+    var _a;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode || !this.viewInfo) {
+      return void 0;
+    }
+    let potentialMatch = getParent(assetNode, this.viewInfo);
+    if (query === void 0) {
+      if (potentialMatch) {
+        const resolved = this.viewInfo.resolvedMap.get(potentialMatch);
+        return resolved == null ? void 0 : resolved.value;
+      }
+      return;
+    }
+    const queryArray = Array.isArray(query) ? [...query] : [query];
+    let parentQuery = queryArray.shift();
+    let depth = 0;
+    while (potentialMatch && parentQuery) {
+      if (depth++ >= 50) {
+        throw new Error("Recursion depth exceeded. Check for cycles in the AST graph");
+      }
+      const matcher = createMatcher(parentQuery);
+      const resolved = this.viewInfo.resolvedMap.get(potentialMatch);
+      if (resolved && matcher(resolved.value)) {
+        if (queryArray.length === 0) {
+          return resolved.value;
+        }
+        parentQuery = queryArray.shift();
+      }
+      potentialMatch = getParent(potentialMatch, this.viewInfo);
+    }
+    return void 0;
+  }
+  getParentProp(id) {
+    var _a, _b, _c, _d;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode || !this.viewInfo) {
+      return;
+    }
+    let working = assetNode;
+    let parent;
+    while (working) {
+      parent = (working == null ? void 0 : working.parent) && ((_b = this.viewInfo.resolvedMap.get(working.parent)) == null ? void 0 : _b.resolved);
+      if (parent && (parent.type === NodeType.Asset || parent.type === NodeType.View)) {
+        break;
+      }
+      working = working == null ? void 0 : working.parent;
+    }
+    if (parent && "children" in parent) {
+      const childProp = (_c = parent.children) == null ? void 0 : _c.find((child) => child.value === working);
+      return (_d = childProp == null ? void 0 : childProp.path) == null ? void 0 : _d[0];
+    }
+    return void 0;
+  }
+  hasParentContext(id, query) {
+    return Boolean(this.getParent(id, query));
+  }
+  findChildPath(node, query, includeSelfMatch = true) {
+    var _a, _b, _c, _d;
+    if (query.length === 0) {
+      return true;
+    }
+    const [first, ...rest] = query;
+    const matcher = createMatcher(first);
+    if (node.type === NodeType.Asset || node.type === NodeType.View) {
+      const resolved = (_a = this.viewInfo) == null ? void 0 : _a.resolvedMap.get(node);
+      const includesSelf = (_b = includeSelfMatch && resolved && matcher(resolved.value)) != null ? _b : false;
+      const childQuery = includesSelf ? rest : query;
+      if (childQuery.length === 0 && includesSelf) {
+        return true;
+      }
+      if (childQuery.length && (!node.children || node.children.length === 0)) {
+        return false;
+      }
+      if ((_c = node.children) == null ? void 0 : _c.some((childNode) => this.findChildPath(childNode.value, childQuery))) {
+        return true;
+      }
+    } else if (node.type === NodeType.MultiNode && node.values.some((childNode) => this.findChildPath(childNode, query))) {
+      return true;
+    } else if ("children" in node && ((_d = node.children) == null ? void 0 : _d.some((childNode) => this.findChildPath(childNode.value, query)))) {
+      return true;
+    }
+    return false;
+  }
+  hasChildContext(id, query) {
+    var _a;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    const queryArray = Array.isArray(query) ? [...query] : [query];
+    if (!assetNode) {
+      return false;
+    }
+    return this.findChildPath(assetNode, queryArray, false);
+  }
+  getAsset(id) {
+    var _a, _b, _c, _d;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode)
+      return;
+    const sourceNode = (_b = this.viewInfo) == null ? void 0 : _b.resolver.getSourceNode(assetNode);
+    if (!sourceNode)
+      return;
+    return (_d = (_c = this.viewInfo) == null ? void 0 : _c.resolvedMap.get(sourceNode)) == null ? void 0 : _d.value;
+  }
+  getPath(id, query) {
+    var _a, _b;
+    const assetNode = (_a = this.viewInfo) == null ? void 0 : _a.assetIdMap.get(id);
+    if (!assetNode || !this.viewInfo) {
+      return;
+    }
+    let path = [];
+    let queryArray = [];
+    if (query) {
+      queryArray = Array.isArray(query) ? [...query] : [query];
+    }
+    let parentQuery = queryArray.shift();
+    let working = assetNode;
+    const findWorkingChild = (parent) => {
+      var _a2;
+      return (_a2 = parent.children) == null ? void 0 : _a2.find((n) => n.value === working);
+    };
+    while (working !== void 0) {
+      const parent = (working == null ? void 0 : working.parent) && this.viewInfo.resolvedMap.get(working.parent);
+      const parentNode = parent == null ? void 0 : parent.resolved;
+      if (parentNode) {
+        if (parentNode.type === NodeType.MultiNode) {
+          const index = parentNode.values.indexOf(working);
+          if (index !== -1) {
+            const actualIndex = index - parentNode.values.slice(0, index).reduce((undefCount, next) => {
+              var _a2, _b2;
+              return ((_b2 = (_a2 = this.viewInfo) == null ? void 0 : _a2.resolvedMap.get(next)) == null ? void 0 : _b2.value) === void 0 ? undefCount + 1 : undefCount;
+            }, 0);
+            path = [actualIndex, ...path];
+          }
+        } else if ("children" in parentNode) {
+          const childProp = findWorkingChild(parentNode);
+          path = [...(_b = childProp == null ? void 0 : childProp.path) != null ? _b : [], ...path];
+        }
+      }
+      if (parentQuery) {
+        const matcher = createMatcher(parentQuery);
+        if (matcher(parent == null ? void 0 : parent.value)) {
+          parentQuery = queryArray.shift();
+          if (!parentQuery)
+            return path;
+        }
+      }
+      working = working.parent;
+    }
+    return queryArray.length === 0 ? path : void 0;
+  }
+}
+
+export { CheckPathPlugin };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@player-ui/check-path-plugin",
+  "version": "0.0.1-next.1",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {
+    "@player-ui/binding-grammar": "0.0.1-next.1"
+  },
+  "dependencies": {
+    "@player-ui/partial-match-registry": "0.0.1-next.1",
+    "dlv": "^1.1.3",
+    "tapable": "1.1.3",
+    "@types/tapable": "^1.0.5",
+    "@babel/runtime": "7.15.4"
+  },
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts"
+}

package/src/index.ts

@@ -0,0 +1,392 @@
+import type { Player, PlayerPlugin } from '@player-ui/player';
+import type { Node, Resolver } from '@player-ui/view';
+import { NodeType } from '@player-ui/view';
+import type { Asset } from '@player-ui/types';
+import { createObjectMatcher } from '@player-ui/partial-match-registry';
+import dlv from 'dlv';
+
+export type QueryFunction = (asset: Asset) => boolean;
+export type Query = QueryFunction | string | object;
+
+/** Generate a function that matches on the given input */
+function createMatcher(
+  match: number | string | object | QueryFunction
+): QueryFunction {
+  if (typeof match === 'string' || typeof match === 'number') {
+    return createObjectMatcher({ type: match });
+  }
+
+  if (typeof match === 'function') {
+    return match as QueryFunction;
+  }
+
+  return createObjectMatcher(match);
+}
+
+interface ViewInfo {
+  /** The root of the view graph */
+  root?: Node.Node;
+
+  /** A cache of an asset or view's id to it's node */
+  assetIdMap: Map<string, Node.Asset | Node.View>;
+
+  /** A map of a node to it's resolved node and value */
+  resolvedMap: Map<
+    Node.Node,
+    {
+      /** The final resolved AST node */
+      resolved: Node.Node;
+
+      /** The final, resolved value of the node */
+      value: any;
+    }
+  >;
+
+  /** The resolver instance tied to this view. Used to map back to original nodes */
+  resolver: Resolver;
+}
+
+/**
+ * Traverse up the tree until reaching the first asset or view
+ * Returns undefined if no matching parent is found
+ */
+function getParent(
+  node: Node.Node,
+  viewInfo: ViewInfo
+): Node.ViewOrAsset | undefined {
+  let working = node;
+
+  while (
+    working.parent &&
+    working.parent.type !== NodeType.Asset &&
+    working.parent.type !== NodeType.View
+  ) {
+    working = working.parent;
+  }
+
+  const { parent } = working;
+
+  if (
+    parent &&
+    (parent.type === NodeType.Asset || parent.type === NodeType.View)
+  ) {
+    return (viewInfo.resolver.getSourceNode(parent) ??
+      parent) as Node.ViewOrAsset;
+  }
+}
+
+/**
+ * The `check-path-plugin` enables developers to query segments of the view tree for contextual rendering or behavior.
+ * This is best suited to be referenced during the UI rendering phase, where one can make decisions about the rendering of an asset based on where it lies in the tree.
+ */
+export class CheckPathPlugin implements PlayerPlugin {
+  name = 'check-path';
+  private viewInfo?: ViewInfo;
+
+  apply(player: Player) {
+    player.hooks.viewController.tap(this.name, (viewController) => {
+      viewController.hooks.view.tap(this.name, (view) => {
+        view.hooks.resolver.tap(this.name, (resolver: Resolver) => {
+          const viewInfo: ViewInfo = {
+            resolvedMap: new Map(),
+            assetIdMap: new Map(),
+            resolver,
+          };
+          this.viewInfo = viewInfo;
+
+          resolver.hooks.afterResolve.tap(this.name, (value, node) => {
+            const sourceNode = resolver.getSourceNode(node);
+
+            if (sourceNode) {
+              viewInfo.resolvedMap.set(sourceNode, {
+                resolved: node,
+                value,
+              });
+
+              if (node.type === NodeType.Asset || node.type === NodeType.View) {
+                const id = dlv(value, 'id');
+
+                if (id) {
+                  viewInfo.assetIdMap.set(id, node);
+                }
+              }
+            }
+
+            return value;
+          });
+        });
+      });
+    });
+  }
+
+  /**
+   * Starts at the asset with the given id, and walks backwards _up_ the tree until it finds a match for the parent
+   *
+   * @param id - The id of the asset to _start_ at
+   * @param query - A means of matching a parent asset
+   * @returns - The parent object if a match is found, else undefined
+   */
+  public getParent(
+    id: string,
+    query?: Query | Array<Query>
+  ): Asset | undefined {
+    const assetNode = this.viewInfo?.assetIdMap.get(id);
+
+    if (!assetNode || !this.viewInfo) {
+      return undefined;
+    }
+
+    let potentialMatch = getParent(assetNode, this.viewInfo);
+
+    // Handle the case of an empty query (just get the immediate parent)
+    if (query === undefined) {
+      if (potentialMatch) {
+        const resolved = this.viewInfo.resolvedMap.get(potentialMatch);
+
+        return resolved?.value;
+      }
+
+      return;
+    }
+
+    const queryArray = Array.isArray(query) ? [...query] : [query];
+    let parentQuery = queryArray.shift();
+
+    // Keep track of the recursive depth in case we loop forever
+    let depth = 0;
+
+    while (potentialMatch && parentQuery) {
+      if (depth++ >= 50) {
+        throw new Error(
+          'Recursion depth exceeded. Check for cycles in the AST graph'
+        );
+      }
+
+      const matcher = createMatcher(parentQuery);
+      const resolved = this.viewInfo.resolvedMap.get(potentialMatch);
+
+      if (resolved && matcher(resolved.value)) {
+        // This is the last match.
+        if (queryArray.length === 0) {
+          return resolved.value;
+        }
+
+        parentQuery = queryArray.shift();
+      }
+
+      potentialMatch = getParent(potentialMatch, this.viewInfo);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Returns the property that the asset resides on relative to it's parent
+   *
+   * @param id - The id of the asset to _start_ at
+   * @returns - The property name or undefined if no parent was found
+   */
+  public getParentProp(id: string): string | number | undefined {
+    const assetNode = this.viewInfo?.assetIdMap.get(id);
+
+    if (!assetNode || !this.viewInfo) {
+      return;
+    }
+
+    let working: Node.Node | undefined = assetNode;
+    let parent;
+
+    while (working) {
+      parent =
+        working?.parent &&
+        this.viewInfo.resolvedMap.get(working.parent)?.resolved;
+
+      if (
+        parent &&
+        (parent.type === NodeType.Asset || parent.type === NodeType.View)
+      ) {
+        break;
+      }
+
+      working = working?.parent;
+    }
+
+    if (parent && 'children' in parent) {
+      const childProp = parent.children?.find(
+        (child) => child.value === working
+      );
+
+      return childProp?.path?.[0];
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Given the starting node, check to verify that the supplied queries are relevant to the current asset's parents.
+   *
+   * @param id - The id of the asset to _start_ at
+   * @returns - true if the context applies, false if it doesn't
+   */
+  public hasParentContext(id: string, query: Query | Array<Query>): boolean {
+    return Boolean(this.getParent(id, query));
+  }
+
+  /** Search the node for any matching paths in the graph that match the query  */
+  private findChildPath(
+    node: Node.Node,
+    query: Array<Query>,
+    includeSelfMatch = true
+  ): boolean {
+    if (query.length === 0) {
+      return true;
+    }
+
+    const [first, ...rest] = query;
+    const matcher = createMatcher(first);
+
+    if (node.type === NodeType.Asset || node.type === NodeType.View) {
+      const resolved = this.viewInfo?.resolvedMap.get(node);
+      const includesSelf =
+        (includeSelfMatch && resolved && matcher(resolved.value)) ?? false;
+      const childQuery = includesSelf ? rest : query;
+
+      if (childQuery.length === 0 && includesSelf) {
+        return true;
+      }
+
+      if (childQuery.length && (!node.children || node.children.length === 0)) {
+        return false;
+      }
+
+      if (
+        node.children?.some((childNode) =>
+          this.findChildPath(childNode.value, childQuery)
+        )
+      ) {
+        return true;
+      }
+    } else if (
+      node.type === NodeType.MultiNode &&
+      node.values.some((childNode) => this.findChildPath(childNode, query))
+    ) {
+      return true;
+    } else if (
+      'children' in node &&
+      node.children?.some((childNode) =>
+        this.findChildPath(childNode.value, query)
+      )
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Given the starting node, check to verify that the supplied queries are relevant to the current asset's children.
+   *
+   * @param id - The id of the asset to _start_ at
+   * @returns - true if the context applies, false if it doesn't
+   */
+  public hasChildContext(id: string, query: Query | Array<Query>): boolean {
+    const assetNode = this.viewInfo?.assetIdMap.get(id);
+    const queryArray = Array.isArray(query) ? [...query] : [query];
+
+    if (!assetNode) {
+      return false;
+    }
+
+    return this.findChildPath(assetNode, queryArray, false);
+  }
+
+  /** Get the asset represented by id */
+  public getAsset(id: string): Asset | undefined {
+    const assetNode = this.viewInfo?.assetIdMap.get(id);
+    if (!assetNode) return;
+
+    const sourceNode = this.viewInfo?.resolver.getSourceNode(assetNode);
+    if (!sourceNode) return;
+
+    return this.viewInfo?.resolvedMap.get(sourceNode)?.value;
+  }
+
+  /**
+   * Get the path of the asset in the view upto
+   * the asset that matches the query or to the view if no query is provided
+   */
+  public getPath(
+    id: string,
+    query?: Query | Array<Query>
+  ): Array<string | number> | undefined {
+    const assetNode = this.viewInfo?.assetIdMap.get(id);
+
+    if (!assetNode || !this.viewInfo) {
+      return;
+    }
+
+    let path: Array<string | number> = [];
+
+    let queryArray: Query[] = [];
+
+    if (query) {
+      queryArray = Array.isArray(query) ? [...query] : [query];
+    }
+
+    let parentQuery = queryArray.shift();
+
+    let working: Node.Node | undefined = assetNode;
+
+    /** Find the child value for the working value from the given parent */
+    const findWorkingChild = (parent: Node.ViewOrAsset | Node.Value) => {
+      return parent.children?.find((n) => n.value === working);
+    };
+
+    while (working !== undefined) {
+      const parent =
+        working?.parent && this.viewInfo.resolvedMap.get(working.parent);
+
+      const parentNode = parent?.resolved;
+
+      if (parentNode) {
+        if (parentNode.type === NodeType.MultiNode) {
+          const index = parentNode.values.indexOf(working);
+
+          if (index !== -1) {
+            const actualIndex =
+              index -
+              parentNode.values
+                .slice(0, index)
+                .reduce(
+                  (undefCount, next) =>
+                    this.viewInfo?.resolvedMap.get(next)?.value === undefined
+                      ? undefCount + 1
+                      : undefCount,
+                  0
+                );
+
+            path = [actualIndex, ...path];
+          }
+        } else if ('children' in parentNode) {
+          const childProp = findWorkingChild(parentNode);
+          path = [...(childProp?.path ?? []), ...path];
+        }
+      }
+
+      if (parentQuery) {
+        const matcher = createMatcher(parentQuery);
+
+        if (matcher(parent?.value)) {
+          parentQuery = queryArray.shift();
+          if (!parentQuery) return path;
+        }
+      }
+
+      working = working.parent;
+    }
+
+    /* if at the end all queries haven't been consumed, 
+       it means we couldn't find a path till the matching query */
+    return queryArray.length === 0 ? path : undefined;
+  }
+}