@player-ui/player 0.8.0--canary.307.9621 → 0.8.0-next.0

package/src/view/resolver/index.ts

@@ -1,27 +1,27 @@
-import { SyncWaterfallHook, SyncHook } from 'tapable-ts';
-import { setIn, addLast, clone } from 'timm';
-import dlv from 'dlv';
-import { dequal } from 'dequal';
-import type { BindingInstance, BindingLike } from '../../binding';
+import { SyncWaterfallHook, SyncHook } from "tapable-ts";
+import { setIn, addLast, clone } from "timm";
+import dlv from "dlv";
+import { dequal } from "dequal";
+import type { BindingInstance, BindingLike } from "../../binding";
 import type {
   DataModelOptions,
   DataModelWithParser,
   Updates,
-} from '../../data';
-import { DependencyModel, withParser } from '../../data';
-import type { Logger } from '../../logger';
-import type { Node } from '../parser';
-import { NodeType } from '../parser';
+} from "../../data";
+import { DependencyModel, withParser } from "../../data";
+import type { Logger } from "../../logger";
+import type { Node } from "../parser";
+import { NodeType } from "../parser";
 import {
   caresAboutDataChanges,
   toNodeResolveOptions,
   unpackAndPush,
-} from './utils';
-import type { Resolve } from './types';
-import { getNodeID } from '../parser/utils';
+} from "./utils";
+import type { Resolve } from "./types";
+import { getNodeID } from "../parser/utils";
 
-export * from './types';
-export * from './utils';
+export * from "./types";
+export * from "./utils";
 
 interface NodeUpdate extends Resolve.ResolvedNode {
   /** A flag to track if a node has changed since the last resolution */
@@ -40,7 +40,7 @@ const withContext = (model: DataModelWithParser): DataModelWithParser => {
 
     set: (
       transaction: [BindingLike, any][],
-      options?: DataModelOptions
+      options?: DataModelOptions,
     ): Updates => {
       return model.set(transaction, {
         context: { model },
@@ -163,7 +163,7 @@ export class Resolver {
       resolveCache,
       toNodeResolveOptions(this.options),
       undefined,
-      prevASTMap
+      prevASTMap,
     );
     this.resolveCache = resolveCache;
     this.hooks.afterUpdate.call(updated.value);
@@ -190,11 +190,11 @@ export class Resolver {
         if (isFirstUpdate) {
           if (node.type === NodeType.Asset || node.type === NodeType.View) {
             this.logger?.error(
-              `Cache conflict: Found Asset/View nodes that have conflicting ids: ${id}, may cause cache issues.`
+              `Cache conflict: Found Asset/View nodes that have conflicting ids: ${id}, may cause cache issues.`,
             );
           } else if (node.type === NodeType.Value) {
             this.logger?.info(
-              `Cache conflict: Found Value nodes that have conflicting ids: ${id}, may cause cache issues. To improve performance make value node IDs globally unique.`
+              `Cache conflict: Found Value nodes that have conflicting ids: ${id}, may cause cache issues. To improve performance make value node IDs globally unique.`,
             );
           }
         }
@@ -213,10 +213,10 @@ export class Resolver {
     const clonedNode = clone(node);
 
     Object.keys(clonedNode).forEach((key) => {
-      if (key === 'parent') return;
+      if (key === "parent") return;
 
       const value = clonedNode[key];
-      if (typeof value === 'object' && value !== null) {
+      if (typeof value === "object" && value !== null) {
         clonedNode[key] = Array.isArray(value) ? [...value] : { ...value };
       }
     });
@@ -231,13 +231,13 @@ export class Resolver {
     cacheUpdate: Map<Node.Node, Resolve.ResolvedNode>,
     options: Resolve.NodeResolveOptions,
     partiallyResolvedParent: Node.Node | undefined,
-    prevASTMap: Map<Node.Node, Node.Node>
+    prevASTMap: Map<Node.Node, Node.Node>,
   ): NodeUpdate {
     const dependencyModel = new DependencyModel(options.data.model);
 
-    dependencyModel.trackSubset('core');
+    dependencyModel.trackSubset("core");
     const depModelWithParser = withContext(
-      withParser(dependencyModel, this.options.parseBinding)
+      withParser(dependencyModel, this.options.parseBinding),
     );
 
     const resolveOptions = this.hooks.resolveOptions.call(
@@ -251,7 +251,7 @@ export class Resolver {
           this.options.evaluator.evaluate(exp, { model: depModelWithParser }),
         node,
       },
-      node
+      node,
     );
 
     const previousResult = this.getPreviousResult(node);
@@ -261,7 +261,7 @@ export class Resolver {
     const shouldUseLastValue = this.hooks.skipResolve.call(
       !dataChanged,
       node,
-      resolveOptions
+      resolveOptions,
     );
 
     // Shallow clone the node so that changes to it during the resolve steps don't impact the original.
@@ -272,7 +272,7 @@ export class Resolver {
     };
     const resolvedAST = this.hooks.beforeResolve.call(
       clonedNode,
-      resolveOptions
+      resolveOptions,
     ) ?? {
       type: NodeType.Empty,
     };
@@ -292,7 +292,7 @@ export class Resolver {
       const repopulateASTMapFromCache = (
         resolvedNode: Resolve.ResolvedNode,
         AST: Node.Node,
-        ASTParent: Node.Node | undefined
+        ASTParent: Node.Node | undefined,
       ) => {
         const { node: resolvedASTLocal } = resolvedNode;
         this.ASTMap.set(resolvedASTLocal, AST);
@@ -312,13 +312,13 @@ export class Resolver {
           repopulateASTMapFromCache(
             previousChildResult,
             originalChildNode,
-            AST
+            AST,
           );
         };
 
-        if ('children' in resolvedASTLocal) {
+        if ("children" in resolvedASTLocal) {
           resolvedASTLocal.children?.forEach(({ value: childAST }) =>
-            handleChildNode(childAST)
+            handleChildNode(childAST),
           );
         } else if (resolvedASTLocal.type === NodeType.MultiNode) {
           resolvedASTLocal.values.forEach(handleChildNode);
@@ -344,7 +344,7 @@ export class Resolver {
     let resolved = this.hooks.resolve.call(
       undefined,
       resolvedAST,
-      resolveOptions
+      resolveOptions,
     );
 
     let updated = !dequal(previousResult?.value, resolved);
@@ -354,9 +354,9 @@ export class Resolver {
     }
 
     const childDependencies = new Set<BindingInstance>();
-    dependencyModel.trackSubset('children');
+    dependencyModel.trackSubset("children");
 
-    if ('children' in resolvedAST) {
+    if ("children" in resolvedAST) {
       const newChildren = resolvedAST.children?.map((child) => {
         const computedChildTree = this.computeTree(
           child.value,
@@ -365,7 +365,7 @@ export class Resolver {
           cacheUpdate,
           resolveOptions,
           resolvedAST,
-          prevASTMap
+          prevASTMap,
         );
         const {
           dependencies: childTreeDeps,
@@ -380,7 +380,7 @@ export class Resolver {
           if (childNode.type === NodeType.MultiNode && !childNode.override) {
             const arr = addLast(
               dlv(resolved, child.path as any[], []),
-              childValue
+              childValue,
             );
             resolved = setIn(resolved, child.path, arr);
           } else {
@@ -408,7 +408,7 @@ export class Resolver {
           cacheUpdate,
           resolveOptions,
           resolvedAST,
-          prevASTMap
+          prevASTMap,
         );
 
         if (mTree.value !== undefined && mTree.value !== null) {
@@ -425,7 +425,7 @@ export class Resolver {
         }
 
         mTree.dependencies.forEach((bindingDep) =>
-          childDependencies.add(bindingDep)
+          childDependencies.add(bindingDep),
         );
 
         updated = updated || mTree.updated;
@@ -438,17 +438,17 @@ export class Resolver {
     }
 
     childDependencies.forEach((bindingDep) =>
-      dependencyModel.addChildReadDep(bindingDep)
+      dependencyModel.addChildReadDep(bindingDep),
     );
 
-    dependencyModel.trackSubset('core');
+    dependencyModel.trackSubset("core");
     if (previousResult && !updated) {
       resolved = previousResult?.value;
     }
 
     resolved = this.hooks.afterResolve.call(resolved, resolvedAST, {
       ...resolveOptions,
-      getDependencies: (scope?: 'core' | 'children') =>
+      getDependencies: (scope?: "core" | "children") =>
         dependencyModel.getDependencies(scope),
     });
 
@@ -465,7 +465,7 @@ export class Resolver {
     this.hooks.afterNodeUpdate.call(
       node,
       isNestedMultiNode ? partiallyResolvedParent?.parent : rawParent,
-      update
+      update,
     );
     cacheUpdate.set(node, update);
 

package/src/view/resolver/types.ts

@@ -2,24 +2,24 @@ import type {
   Schema,
   Formatting,
   Validation as ValidationTypes,
-} from '@player-ui/types';
+} from "@player-ui/types";
 import type {
   BindingInstance,
   BindingLike,
   BindingFactory,
-} from '../../binding';
+} from "../../binding";
 import type {
   DataModelWithParser,
   DataModelImpl,
   DataModelOptions,
-} from '../../data';
-import type { ConstantsProvider } from '../../controllers/constants';
-import type { TransitionFunction } from '../../controllers';
-import type { ExpressionEvaluator, ExpressionType } from '../../expressions';
-import type { ValidationResponse } from '../../validator';
-import type { Logger } from '../../logger';
-import type { SchemaController } from '../../schema';
-import type { Node } from '../parser';
+} from "../../data";
+import type { ConstantsProvider } from "../../controllers/constants";
+import type { TransitionFunction } from "../../controllers";
+import type { ExpressionEvaluator, ExpressionType } from "../../expressions";
+import type { ValidationResponse } from "../../validator";
+import type { Logger } from "../../logger";
+import type { SchemaController } from "../../schema";
+import type { Node } from "../parser";
 
 export interface ValidationGetResolveOptions {
   /**
@@ -33,6 +33,7 @@ export interface PlayerUtils {
   findPlugin<Plugin = unknown>(symbol: symbol): Plugin | undefined;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-namespace
 export declare namespace Resolve {
   export interface Validation {
     /** Fetch the data-type for the given binding */
@@ -40,7 +41,7 @@ export declare namespace Resolve {
 
     /** Get all currently applicable validation errors */
     getAll(
-      options?: ValidationGetResolveOptions
+      options?: ValidationGetResolveOptions,
     ): Map<BindingInstance, ValidationResponse> | undefined;
 
     /** Internal Method to lookup if there is a validation for the given binding */
@@ -48,12 +49,12 @@ export declare namespace Resolve {
       | {
           /** Get the validation for the given binding */
           get: (
-            options?: ValidationGetResolveOptions
+            options?: ValidationGetResolveOptions,
           ) => ValidationResponse | undefined;
 
           /** Get all validations for the given binding */
           getAll: (
-            options?: ValidationGetResolveOptions
+            options?: ValidationGetResolveOptions,
           ) => Array<ValidationResponse>;
         }
       | undefined;
@@ -64,7 +65,7 @@ export declare namespace Resolve {
       options?: {
         /** If this binding should also be tracked for validations */
         track?: boolean;
-      } & ValidationGetResolveOptions
+      } & ValidationGetResolveOptions,
     ): ValidationResponse | undefined;
 
     getValidationsForBinding(
@@ -72,12 +73,12 @@ export declare namespace Resolve {
       options?: {
         /** If this binding should also be tracked for validations */
         track?: boolean;
-      } & ValidationGetResolveOptions
+      } & ValidationGetResolveOptions,
     ): Array<ValidationResponse>;
 
     /** Get errors for all children regardless of section */
     getChildren(
-      type?: ValidationTypes.DisplayTarget
+      type?: ValidationTypes.DisplayTarget,
     ): Array<ValidationResponse>;
 
     /** Get errors for all children solely in this section */
@@ -89,7 +90,7 @@ export declare namespace Resolve {
     /** Register node as a section */
     register: (options?: {
       /** While type of Display Target group it should register as */
-      type: Exclude<ValidationTypes.DisplayTarget, 'field'>;
+      type: Exclude<ValidationTypes.DisplayTarget, "field">;
     }) => void;
   }
 
@@ -141,7 +142,7 @@ export declare namespace Resolve {
     data: NodeDataOptions;
 
     /** The data dependencies that were requested during the resolution */
-    getDependencies?(scope?: 'core' | 'children'): Set<BindingInstance>;
+    getDependencies?(scope?: "core" | "children"): Set<BindingInstance>;
 
     /** original node */
     node?: Node.Node;
@@ -180,13 +181,13 @@ export declare namespace Resolve {
 
   export type NodeTransformFunction = (
     node: Node.Node,
-    options: NodeResolveOptions
+    options: NodeResolveOptions,
   ) => Node.Node | null;
 
   export type NodeResolveFunction = (
     value: any,
     node: Node.Node,
-    options: NodeResolveOptions
+    options: NodeResolveOptions,
   ) => any;
 
   export interface Plugin {

package/src/view/resolver/utils.ts

@@ -1,12 +1,12 @@
-import type { BindingInstance, BindingLike } from '../../binding';
-import { isBinding } from '../../binding';
-import type { ExpressionType } from '../../expressions';
-import type { Resolve } from './types';
+import type { BindingInstance, BindingLike } from "../../binding";
+import { isBinding } from "../../binding";
+import type { ExpressionType } from "../../expressions";
+import type { Resolve } from "./types";
 
 /** Check to see if and of the data-changes affect the given dependencies  */
 export function caresAboutDataChanges(
   dataChanges?: Set<BindingInstance>,
-  dependencies?: Set<BindingInstance>
+  dependencies?: Set<BindingInstance>,
 ) {
   if (!dataChanges || !dependencies) {
     return true;
@@ -20,15 +20,15 @@ export function caresAboutDataChanges(
       (dep) =>
         !!dataChangeArray.find(
           (change) =>
-            change === dep || change.contains(dep) || dep.contains(change)
-        )
+            change === dep || change.contains(dep) || dep.contains(change),
+        ),
     ) !== undefined
   );
 }
 
 /** Convert the options object for a resolver to one for a node */
 export function toNodeResolveOptions(
-  resolverOptions: Resolve.ResolverOptions
+  resolverOptions: Resolve.ResolverOptions,
 ): Resolve.NodeResolveOptions {
   return {
     ...resolverOptions,
@@ -47,7 +47,7 @@ export function toNodeResolveOptions(
               isBinding(bindingLike)
                 ? bindingLike
                 : resolverOptions.parseBinding(bindingLike),
-              value
+              value,
             )
           : value,
     },

package/src/view/view.ts

@@ -1,18 +1,18 @@
-import { SyncHook } from 'tapable-ts';
-import type { View as ViewType } from '@player-ui/types';
-import type { BindingInstance, BindingFactory } from '../binding';
-import type { ValidationProvider, ValidationObject } from '../validator';
-import type { Logger } from '../logger';
-import type { Resolve } from './resolver';
-import { Resolver, toNodeResolveOptions } from './resolver';
-import type { Node } from './parser';
-import { Parser } from './parser';
+import { SyncHook } from "tapable-ts";
+import type { View as ViewType } from "@player-ui/types";
+import type { BindingInstance, BindingFactory } from "../binding";
+import type { ValidationProvider, ValidationObject } from "../validator";
+import type { Logger } from "../logger";
+import type { Resolve } from "./resolver";
+import { Resolver, toNodeResolveOptions } from "./resolver";
+import type { Node } from "./parser";
+import { Parser } from "./parser";
 import {
   TemplatePlugin,
   StringResolverPlugin,
   ApplicabilityPlugin,
   SwitchPlugin,
-} from './plugins';
+} from "./plugins";
 
 /**
  * Manages the view level validations
@@ -36,7 +36,7 @@ class CrossfieldProvider implements ValidationProvider {
 
     if (!Array.isArray(xfieldRefs)) {
       this.logger?.warn(
-        `Unable to register view validations for id: ${contentView.id}. 'validation' property must be an Array.`
+        `Unable to register view validations for id: ${contentView.id}. 'validation' property must be an Array.`,
       );
 
       return;
@@ -49,8 +49,8 @@ class CrossfieldProvider implements ValidationProvider {
       // x-field validations by default are triggered by navigating away from the page
       // the reference can also override that _or_ the severity
       const withDefaults: ValidationObject = {
-        trigger: 'navigation',
-        severity: 'error',
+        trigger: "navigation",
+        severity: "error",
         ...vRef,
       };
 
@@ -83,6 +83,7 @@ export class ViewInstance implements ValidationProvider {
     onUpdate: new SyncHook<[ViewType]>(),
     parser: new SyncHook<[Parser]>(),
     resolver: new SyncHook<[Resolver]>(),
+    onTemplatePluginCreated: new SyncHook<[TemplatePlugin]>(),
     templatePlugin: new SyncHook<[TemplatePlugin]>(),
   };
 
@@ -93,7 +94,7 @@ export class ViewInstance implements ValidationProvider {
 
   private validationProvider?: CrossfieldProvider;
 
-  private templatePlugin: TemplatePlugin;
+  private templatePlugin: TemplatePlugin | undefined;
 
   // TODO might want to add a version/timestamp to this to compare updates
   public lastUpdate: Record<string, any> | undefined;
@@ -101,12 +102,9 @@ export class ViewInstance implements ValidationProvider {
   constructor(initialView: ViewType, resolverOptions: Resolve.ResolverOptions) {
     this.initialView = initialView;
     this.resolverOptions = resolverOptions;
-    const pluginOptions = toNodeResolveOptions(resolverOptions);
-    new SwitchPlugin(pluginOptions).apply(this);
-    new ApplicabilityPlugin().apply(this);
-    new StringResolverPlugin().apply(this);
-    this.templatePlugin = new TemplatePlugin(pluginOptions);
-    this.templatePlugin.apply(this);
+    this.hooks.onTemplatePluginCreated.tap("view", (templatePlugin) => {
+      this.templatePlugin = templatePlugin;
+    });
   }
 
   public updateAsync() {
@@ -121,10 +119,16 @@ export class ViewInstance implements ValidationProvider {
       this.validationProvider = new CrossfieldProvider(
         this.initialView,
         this.resolverOptions.parseBinding,
-        this.resolverOptions.logger
+        this.resolverOptions.logger,
       );
 
-      this.hooks.templatePlugin.call(this.templatePlugin);
+      if (this.templatePlugin) {
+        this.hooks.templatePlugin.call(this.templatePlugin);
+      } else {
+        this.resolverOptions.logger?.warn(
+          "templatePlugin not set for View, legacy templates may not work",
+        );
+      }
 
       const parser = new Parser();
       this.hooks.parser.call(parser);
@@ -153,3 +157,9 @@ export class ViewInstance implements ValidationProvider {
     return this.validationProvider?.getValidationsForBinding(binding);
   }
 }
+
+/** A plugin for a view */
+export interface ViewPlugin {
+  /** Called with a view instance */
+  apply(view: ViewInstance): void;
+}

package/types/binding/binding.d.ts

@@ -0,0 +1,50 @@
+export interface BindingParserOptions {
+    /** Get the value for a specific binding */
+    get: (binding: BindingInstance) => any;
+    /**
+     * Set the values for bindings.
+     * This is used when the query syntax needs to modify an object
+     */
+    set: (transaction: Array<[BindingInstance, any]>) => void;
+    /**
+     * Get the result of evaluating an expression
+     */
+    evaluate: (exp: string) => any;
+    /**
+     * Without readOnly, if a binding such as this is used: arr[key='does not exist'],
+     * then an object with that key will be created.
+     * This is done to make assignment such as arr[key='abc'].val = 'foo' work smoothly.
+     * Setting readOnly to true will prevent this behavior, avoiding unintended data changes.
+     */
+    readOnly?: boolean;
+}
+export type Getter = (path: BindingInstance) => any;
+export type RawBindingSegment = number | string;
+export type RawBinding = string | RawBindingSegment[];
+export type BindingLike = RawBinding | BindingInstance;
+export type BindingFactory = (raw: RawBinding, options?: Partial<BindingParserOptions>) => BindingInstance;
+/**
+ * A path in the data model
+ */
+export declare class BindingInstance {
+    private split;
+    private joined;
+    private factory;
+    constructor(raw: RawBinding, factory?: (rawBinding: RawBinding) => BindingInstance);
+    asArray(): RawBindingSegment[];
+    asString(): string;
+    /**
+     * Check to see if the given binding is a sub-path of the current one
+     */
+    contains(binding: BindingInstance): boolean;
+    relative(binding: BindingInstance): RawBindingSegment[];
+    parent(): BindingInstance;
+    key(): RawBindingSegment;
+    /**
+     * This is a utility method to get a binding that is a descendent of this binding
+     *
+     * @param relative - The relative path to descend to
+     */
+    descendent(relative: BindingLike): BindingInstance;
+}
+//# sourceMappingURL=binding.d.ts.map

package/types/binding/index.d.ts

@@ -0,0 +1,29 @@
+import { SyncBailHook, SyncWaterfallHook } from "tapable-ts";
+import type { AnyNode } from "../binding-grammar/index";
+import type { BindingParserOptions, BindingLike } from "./binding";
+import { BindingInstance } from "./binding";
+import type { NormalizedResult, ResolveBindingASTOptions } from "./resolver";
+export * from "./utils";
+export * from "./binding";
+export declare const SIMPLE_BINDING_REGEX: RegExp;
+export declare const BINDING_BRACKETS_REGEX: RegExp;
+type BeforeResolveNodeContext = Required<NormalizedResult> & ResolveBindingASTOptions;
+/** A parser for creating bindings from a string */
+export declare class BindingParser {
+    private cache;
+    private parseCache;
+    private parserOptions;
+    hooks: {
+        skipOptimization: SyncBailHook<[string], boolean, Record<string, any>>;
+        beforeResolveNode: SyncWaterfallHook<[AnyNode, BeforeResolveNodeContext], Record<string, any>>;
+    };
+    constructor(options?: Partial<BindingParserOptions>);
+    /**
+     * Takes a binding path, parses it, and returns an equivalent, normalized
+     * representation of that path.
+     */
+    private normalizePath;
+    private getBindingForNormalizedResult;
+    parse(rawBinding: BindingLike, overrides?: Partial<BindingParserOptions>): BindingInstance;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/binding/resolver.d.ts

@@ -0,0 +1,26 @@
+import type { SyncWaterfallHook } from "tapable-ts";
+import type { PathNode, AnyNode } from "../binding-grammar";
+export interface NormalizedResult {
+    /** The normalized path */
+    path: Array<string | number>;
+    /** Any new updates that need to happen for this binding to be resolved */
+    updates?: Record<string, any>;
+}
+export interface ResolveBindingASTOptions {
+    /** Get the value of the model at the given path */
+    getValue: (path: Array<string | number>) => any;
+    /** Convert the value into valid path segments */
+    convertToPath: (value: any) => string;
+    /** Convert the value into valid path segments */
+    evaluate: (exp: string) => any;
+}
+export interface ResolveBindingASTHooks {
+    /** A hook for transforming a node before fully resolving it */
+    beforeResolveNode: SyncWaterfallHook<[
+        AnyNode,
+        Required<NormalizedResult> & ResolveBindingASTOptions
+    ]>;
+}
+/** Given a binding AST, resolve it */
+export declare function resolveBindingAST(bindingPathNode: PathNode, options: ResolveBindingASTOptions, hooks?: ResolveBindingASTHooks): NormalizedResult;
+//# sourceMappingURL=resolver.d.ts.map

package/types/binding/utils.d.ts

@@ -0,0 +1,12 @@
+import type { BindingLike, BindingInstance } from "./binding";
+/** Check if the parameter representing a binding is already of the Binding class */
+export declare function isBinding(binding: BindingLike): binding is BindingInstance;
+/** Convert the string to an int if you can, otherwise just return the original string */
+export declare function maybeConvertToNum(i: string): string | number;
+/**
+ * utility to convert binding into binding segments.
+ */
+export declare function getBindingSegments(binding: BindingLike): Array<string | number>;
+/** Like _.findIndex, but ignores types */
+export declare function findInArray<T extends Record<string | number, object>>(array: Array<T>, key: string | number, value: T): number | undefined;
+//# sourceMappingURL=utils.d.ts.map