@player-ui/player 0.3.0-next.2 → 0.3.0-next.4

package/package.json

@@ -1,30 +1,24 @@
 {
   "name": "@player-ui/player",
-  "version": "0.3.0-next.2",
+  "version": "0.3.0-next.4",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {},
   "dependencies": {
-    "@player-ui/binding": "0.3.0-next.2",
-    "@player-ui/constants": "0.3.0-next.2",
-    "@player-ui/data": "0.3.0-next.2",
-    "@player-ui/expressions": "0.3.0-next.2",
-    "@player-ui/flow": "0.3.0-next.2",
-    "@player-ui/logger": "0.3.0-next.2",
-    "@player-ui/partial-match-registry": "0.3.0-next.2",
-    "@player-ui/schema": "0.3.0-next.2",
-    "@player-ui/string-resolver": "0.3.0-next.2",
-    "@player-ui/types": "0.3.0-next.2",
-    "@player-ui/utils": "0.3.0-next.2",
-    "@player-ui/validator": "0.3.0-next.2",
-    "@player-ui/view": "0.3.0-next.2",
-    "babel-plugin-preval": "^5.0.0",
+    "@player-ui/partial-match-registry": "0.3.0-next.4",
+    "@player-ui/types": "0.3.0-next.4",
     "dequal": "^2.0.2",
     "p-defer": "^3.0.0",
     "queue-microtask": "^1.2.3",
     "tapable-ts": "^0.1.0",
+    "nested-error-stacks": "^2.1.1",
+    "@types/nested-error-stacks": "^2.1.0",
+    "parsimmon": "^1.12.0",
+    "@types/parsimmon": "^1.10.0",
+    "arr-flatten": "^1.1.0",
+    "ebnf": "^1.9.0",
     "timm": "^1.6.2",
     "@babel/runtime": "7.15.4"
   },

package/src/binding/binding.ts

@@ -0,0 +1,108 @@
+import { getBindingSegments } from './utils';
+
+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;
+}
+
+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 class BindingInstance {
+  private split: RawBindingSegment[];
+  private joined: string;
+  private factory: BindingFactory;
+
+  constructor(
+    raw: RawBinding,
+    factory = (rawBinding: RawBinding) => new BindingInstance(rawBinding)
+  ) {
+    const split = Array.isArray(raw) ? raw : raw.split('.');
+    this.split = split.map((segment) => {
+      if (typeof segment === 'number') {
+        return segment;
+      }
+
+      const tryNum = Number(segment);
+      return isNaN(tryNum) ? segment : tryNum;
+    });
+    Object.freeze(this.split);
+    this.joined = this.split.join('.');
+    this.factory = factory;
+  }
+
+  asArray(): RawBindingSegment[] {
+    return this.split;
+  }
+
+  asString(): string {
+    return this.joined;
+  }
+
+  /**
+   * Check to see if the given binding is a sub-path of the current one
+   */
+  contains(binding: BindingInstance): boolean {
+    // need to account for partial key matches
+    // [foo, bar] !== [foo, ba]
+    const bindingAsArray = binding.asArray();
+
+    if (bindingAsArray.length < this.split.length) {
+      return false;
+    }
+
+    // Check every overlapping index to make sure they're the same
+    // Intentionally use a for loop for speeeed
+    for (let i = 0; i < this.split.length; i++) {
+      if (this.split[i] !== bindingAsArray[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  relative(binding: BindingInstance): RawBindingSegment[] {
+    return this.asArray().slice(binding.asArray().length);
+  }
+
+  parent(): BindingInstance {
+    return this.factory(this.split.slice(0, -1));
+  }
+
+  key(): RawBindingSegment {
+    return this.split[this.split.length - 1];
+  }
+
+  /**
+   * 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 {
+    const descendentSegments = getBindingSegments(relative);
+
+    return this.factory(this.split.concat(descendentSegments));
+  }
+}

package/src/binding/index.ts

@@ -0,0 +1,188 @@
+import { SyncBailHook, SyncWaterfallHook } from 'tapable-ts';
+import NestedError from 'nested-error-stacks';
+import type { ParserResult, AnyNode } from '../binding-grammar';
+import {
+  // We can swap this with whichever parser we want to use
+  parseCustom as parseBinding,
+} from '../binding-grammar';
+import type { BindingParserOptions, BindingLike } from './binding';
+import { BindingInstance } from './binding';
+import { isBinding } from './utils';
+import type { NormalizedResult, ResolveBindingASTOptions } from './resolver';
+import { resolveBindingAST } from './resolver';
+
+export * from './utils';
+export * from './binding';
+
+export const SIMPLE_BINDING_REGEX = /^[\w\-@]+(\.[\w\-@]+)*$/;
+
+const DEFAULT_OPTIONS: BindingParserOptions = {
+  get: () => {
+    throw new Error('Not Implemented');
+  },
+  set: () => {
+    throw new Error('Not Implemented');
+  },
+  evaluate: () => {
+    throw new Error('Not Implemented');
+  },
+};
+
+/** A parser for creating bindings from a string */
+export class BindingParser {
+  private cache: Record<string, BindingInstance>;
+  private parseCache: Record<string, ParserResult>;
+  private parserOptions: BindingParserOptions;
+
+  public hooks = {
+    skipOptimization: new SyncBailHook<[string], boolean>(),
+    beforeResolveNode: new SyncWaterfallHook<
+      [AnyNode, Required<NormalizedResult> & ResolveBindingASTOptions]
+    >(),
+  };
+
+  constructor(options?: Partial<BindingParserOptions>) {
+    this.parserOptions = { ...DEFAULT_OPTIONS, ...options };
+    this.cache = {};
+    this.parseCache = {};
+    this.parse = this.parse.bind(this);
+  }
+
+  /**
+   * Takes a binding path, parses it, and returns an equivalent, normalized
+   * representation of that path.
+   */
+  private normalizePath(
+    path: string,
+    resolveOptions: ResolveBindingASTOptions
+  ) {
+    if (
+      path.match(SIMPLE_BINDING_REGEX) &&
+      this.hooks.skipOptimization.call(path) !== true
+    ) {
+      return { path: path.split('.'), updates: undefined } as NormalizedResult;
+    }
+
+    const ast = this.parseCache[path] ?? parseBinding(path);
+    this.parseCache[path] = ast;
+
+    if (typeof ast !== 'object' || !ast?.status) {
+      throw new TypeError(
+        `Cannot normalize path "${path}": ${ast?.error ?? 'Unknown Error.'}`
+      );
+    }
+
+    try {
+      return resolveBindingAST(ast.path, resolveOptions, this.hooks);
+    } catch (e: any) {
+      throw new NestedError(`Cannot resolve binding: ${path}`, e);
+    }
+  }
+
+  private getBindingForNormalizedResult(
+    normalized: NormalizedResult
+  ): BindingInstance {
+    const normalizedStr = normalized.path.join('.');
+
+    if (this.cache[normalizedStr]) {
+      return this.cache[normalizedStr];
+    }
+
+    const created = new BindingInstance(
+      normalizedStr === '' ? [] : normalized.path,
+      this.parse
+    );
+    this.cache[normalizedStr] = created;
+
+    return created;
+  }
+
+  public parse(
+    rawBinding: BindingLike,
+    overrides: Partial<BindingParserOptions> = {}
+  ): BindingInstance {
+    if (isBinding(rawBinding)) {
+      return rawBinding;
+    }
+
+    const options = {
+      ...this.parserOptions,
+      ...overrides,
+    };
+
+    let updates: Record<string, any> = {};
+
+    const joined = Array.isArray(rawBinding)
+      ? rawBinding.join('.')
+      : String(rawBinding);
+
+    const normalizeConfig: ResolveBindingASTOptions = {
+      getValue: (path: Array<string | number>) => {
+        const normalized = this.normalizePath(path.join('.'), normalizeConfig);
+
+        return options.get(this.getBindingForNormalizedResult(normalized));
+      },
+      evaluate: (exp) => {
+        return options.evaluate(exp);
+      },
+      convertToPath: (path: any) => {
+        if (path === undefined) {
+          throw new Error(
+            'Attempted to convert undefined value to binding path'
+          );
+        }
+
+        if (
+          typeof path !== 'string' &&
+          typeof path !== 'number' &&
+          typeof path !== 'boolean'
+        ) {
+          throw new Error(
+            `Attempting to convert ${typeof path} to a binding path.`
+          );
+        }
+
+        const normalized = this.normalizePath(String(path), normalizeConfig);
+
+        if (normalized.updates) {
+          updates = {
+            ...updates,
+            ...normalized.updates,
+          };
+        }
+
+        const joinedNormalizedPath = normalized.path.join('.');
+
+        if (joinedNormalizedPath === '') {
+          throw new Error('Nested path resolved to an empty path');
+        }
+
+        return joinedNormalizedPath;
+      },
+    };
+
+    const normalized = this.normalizePath(joined, normalizeConfig);
+
+    if (normalized.updates) {
+      updates = {
+        ...updates,
+        ...normalized.updates,
+      };
+    }
+
+    const updateKeys = Object.keys(updates);
+
+    if (updateKeys.length > 0) {
+      const updateTransaction = updateKeys.map<[BindingInstance, any]>(
+        (updatedBinding) => [
+          this.parse(updatedBinding),
+          updates[updatedBinding],
+        ]
+      );
+
+      options.set(updateTransaction);
+    }
+
+    return this.getBindingForNormalizedResult(normalized);
+  }
+}

package/src/binding/resolver.ts

@@ -0,0 +1,157 @@
+import NestedError from 'nested-error-stacks';
+import type { SyncWaterfallHook } from 'tapable-ts';
+import type { PathNode, AnyNode } from '../binding-grammar';
+
+import { maybeConvertToNum } from '.';
+import { findInArray } from './utils';
+
+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 function resolveBindingAST(
+  bindingPathNode: PathNode,
+  options: ResolveBindingASTOptions,
+  hooks?: ResolveBindingASTHooks
+): NormalizedResult {
+  const context: Required<NormalizedResult> = {
+    updates: {},
+    path: [],
+  };
+
+  // let updates: Record<string, any> = {};
+  // const path: Array<string | number> = [];
+
+  /** Get the value for any child node */
+  function getValueForNode(node: AnyNode): any {
+    if (node.name === 'Value') {
+      return node.value;
+    }
+
+    if (node.name === 'PathNode') {
+      const nestedResolvedValue = resolveBindingAST(node, options);
+
+      if (nestedResolvedValue.updates) {
+        context.updates = {
+          ...context.updates,
+          ...nestedResolvedValue.updates,
+        };
+      }
+
+      try {
+        return options.convertToPath(
+          options.getValue(nestedResolvedValue.path)
+        );
+      } catch (e: any) {
+        throw new NestedError(
+          `Unable to resolve path segment: ${nestedResolvedValue.path}`,
+          e
+        );
+      }
+    }
+
+    if (node.name === 'Expression') {
+      try {
+        const actualValue = options.evaluate(node.value);
+
+        return options.convertToPath(actualValue);
+      } catch (e: any) {
+        throw new NestedError(`Unable to resolve path: ${node.value}`, e);
+      }
+    }
+
+    throw new Error(`Unable to resolve value for node: ${node.name}`);
+  }
+
+  /** Handle when path segments are binding paths (foo.bar) or single segments (foo) */
+  function appendPathSegments(segment: string | number) {
+    if (typeof segment === 'string' && segment.indexOf('.') > -1) {
+      segment.split('.').forEach((i) => {
+        context.path.push(maybeConvertToNum(i));
+      });
+    } else {
+      context.path.push(segment);
+    }
+  }
+
+  /** Compute the _actual_ binding val from the AST */
+  function resolveNode(_node: AnyNode) {
+    const resolvedNode =
+      hooks?.beforeResolveNode.call(_node, { ...context, ...options }) ?? _node;
+
+    switch (resolvedNode.name) {
+      case 'Expression':
+      case 'PathNode':
+        appendPathSegments(getValueForNode(resolvedNode));
+        break;
+
+      case 'Value':
+        appendPathSegments(resolvedNode.value);
+        break;
+
+      case 'Query': {
+        // Look for an object at the path with the given key/val criteria
+        const objToQuery: Record<string, any>[] =
+          options.getValue(context.path) ?? [];
+
+        const { key, value } = resolvedNode;
+
+        const resolvedKey = getValueForNode(key);
+        const resolvedValue = value && getValueForNode(value);
+
+        const index = findInArray(objToQuery, resolvedKey, resolvedValue);
+
+        if (index === undefined || index === -1) {
+          context.updates[
+            [...context.path, objToQuery.length, resolvedKey].join('.')
+          ] = resolvedValue;
+          context.path.push(objToQuery.length);
+        } else {
+          context.path.push(index);
+        }
+
+        break;
+      }
+
+      case 'Concatenated':
+        context.path.push(resolvedNode.value.map(getValueForNode).join(''));
+        break;
+
+      default:
+        throw new Error(`Unsupported node type: ${(resolvedNode as any).name}`);
+    }
+  }
+
+  bindingPathNode.path.forEach(resolveNode);
+
+  return {
+    path: context.path,
+    updates:
+      Object.keys(context.updates ?? {}).length > 0
+        ? context.updates
+        : undefined,
+  };
+}

package/src/binding/utils.ts

@@ -0,0 +1,51 @@
+import type { BindingLike, BindingInstance } from './binding';
+
+/** Check if the parameter representing a binding is already of the Binding class */
+export function isBinding(binding: BindingLike): binding is BindingInstance {
+  return !(typeof binding === 'string' || Array.isArray(binding));
+}
+
+/** Convert the string to an int if you can, otherwise just return the original string */
+export function maybeConvertToNum(i: string): string | number {
+  const asInt = parseInt(i, 10);
+
+  if (isNaN(asInt)) {
+    return i;
+  }
+
+  return asInt;
+}
+
+/**
+ * utility to convert binding into binding segments.
+ */
+export function getBindingSegments(
+  binding: BindingLike
+): Array<string | number> {
+  if (Array.isArray(binding)) {
+    return binding;
+  }
+
+  if (typeof binding === 'string') {
+    return binding.split('.');
+  }
+
+  return binding.asArray();
+}
+
+/** Like _.findIndex, but ignores types */
+export function findInArray<T extends Record<string | number, object>>(
+  array: Array<T>,
+  key: string | number,
+  value: T
+): number | undefined {
+  return array.findIndex((obj) => {
+    if (obj && typeof obj === 'object') {
+      // Intentional double-equals because we want '4' to be coerced to 4
+      // eslint-disable-next-line eqeqeq
+      return obj[key] == value;
+    }
+
+    return false;
+  });
+}

package/src/binding-grammar/ast.ts

@@ -0,0 +1,113 @@
+export interface Node<T extends string> {
+  /** The basic node type */
+  name: T;
+}
+
+/**
+ * An AST node that represents a nested path in the model
+ * foo.{{bar}}.baz (this is {{bar}})
+ */
+export interface PathNode extends Node<'PathNode'> {
+  /** The path in the model that this node represents */
+  path: Array<AnyNode>;
+}
+
+/**
+ * A segment representing a query
+ * [foo=bar]
+ */
+export interface QueryNode extends Node<'Query'> {
+  /** The key to query */
+  key: AnyNode;
+
+  /** The target value */
+  value?: AnyNode;
+}
+
+/** A simple segment */
+export interface ValueNode extends Node<'Value'> {
+  /** The segment value */
+  value: string | number;
+}
+
+/** A nested expression */
+export interface ExpressionNode extends Node<'Expression'> {
+  /** The expression */
+  value: string;
+}
+
+/** Helper to create a value node */
+export const toValue = (value: string | number): ValueNode => ({
+  name: 'Value',
+  value,
+});
+
+/** Helper to create an expression node */
+export const toExpression = (value: string): ExpressionNode => ({
+  name: 'Expression',
+  value,
+});
+
+/** Helper to create a nested path node */
+export const toPath = (path: Array<AnyNode>): PathNode => ({
+  name: 'PathNode',
+  path,
+});
+
+/** Helper to create a query node */
+export const toQuery = (key: AnyNode, value?: AnyNode): QueryNode => ({
+  name: 'Query',
+  key,
+  value,
+});
+
+/** Create a concat node */
+export const toConcatenatedNode = (
+  values: Array<PathNode | ValueNode | ExpressionNode>
+): PathNode | ValueNode | ConcatenatedNode | ExpressionNode => {
+  if (values.length === 1) {
+    return values[0];
+  }
+
+  return {
+    name: 'Concatenated',
+    value: values,
+  };
+};
+
+/**
+ * A binding segment that's multiple smaller ones
+ * {{foo}}_bar_{{baz}}
+ */
+export interface ConcatenatedNode extends Node<'Concatenated'> {
+  /** A list of nested paths, or value nodes to concat together to form a segment */
+  value: Array<PathNode | ValueNode | ExpressionNode>;
+}
+
+export type AnyNode =
+  | PathNode
+  | QueryNode
+  | ValueNode
+  | ConcatenatedNode
+  | ExpressionNode;
+export type Path = Array<AnyNode>;
+
+export interface ParserSuccessResult {
+  /** A successful parse result */
+  status: true;
+
+  /** The path the binding represents */
+  path: PathNode;
+}
+
+export interface ParserFailureResult {
+  /** A failed parse result */
+  status: false;
+
+  /** The message representing the reason the parse result failed */
+  error: string;
+}
+
+export type ParserResult = ParserSuccessResult | ParserFailureResult;
+
+export type Parser = (raw: string) => ParserResult;