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

package/src/binding-grammar/ebnf/index.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
-import { Grammars } from 'ebnf';
+import { Grammars } from "ebnf";
 import type {
   Parser,
   AnyNode,
@@ -8,14 +8,14 @@ import type {
   ConcatenatedNode,
   QueryNode,
   ExpressionNode,
-} from '../ast';
+} from "../ast";
 import {
   toValue,
   toQuery,
   toPath,
   toConcatenatedNode,
   toExpression,
-} from '../ast';
+} from "../ast";
 import type {
   ValueToken,
   ModelRefToken,
@@ -26,7 +26,7 @@ import type {
   QueryToken,
   QuotedValueToken,
   ExpressionToken,
-} from './types';
+} from "./types";
 
 const parser = new Grammars.W3C.Parser(`
 value                      ::= segment_and_bracket (SEGMENT_SEPARATOR segment_and_bracket)*
@@ -66,20 +66,20 @@ function convertExpressionToken(token: ExpressionToken): ExpressionNode {
 
 /** map a concatenated token to a node */
 function convertConcatenatedToken(
-  token: ConcatenatedToken
+  token: ConcatenatedToken,
 ): ConcatenatedNode | ValueNode | PathNode | ExpressionNode {
   return toConcatenatedNode(
     token.children.map((child) => {
-      if (child.type === 'identifier') {
+      if (child.type === "identifier") {
         return convertIdentifierToken(child);
       }
 
-      if (child.type === 'expression') {
+      if (child.type === "expression") {
         return convertExpressionToken(child);
       }
 
       return convertModelRefToken(child);
-    })
+    }),
   );
 }
 
@@ -90,15 +90,15 @@ function convertQuotedValueToken(token: QuotedValueToken): ValueNode {
 
 /** map a quoted value token to a value node */
 function convertOptionallyQuotedToken(
-  token: OptionallyQuotedSegment
+  token: OptionallyQuotedSegment,
 ): ValueNode | ConcatenatedNode | PathNode | ExpressionNode {
   const child = token.children[0];
-  if (child.type === 'quoted_value') {
+  if (child.type === "quoted_value") {
     return convertQuotedValueToken(child);
   }
 
   const grandChild = child.children[0];
-  if (grandChild.type === 'identifier') {
+  if (grandChild.type === "identifier") {
     return convertIdentifierToken(grandChild);
   }
 
@@ -109,7 +109,7 @@ function convertOptionallyQuotedToken(
 function convertQueryToken(token: QueryToken): QueryNode {
   return toQuery(
     convertOptionallyQuotedToken(token.children[0]),
-    convertOptionallyQuotedToken(token.children[1])
+    convertOptionallyQuotedToken(token.children[1]),
   );
 }
 
@@ -120,22 +120,22 @@ function convertValueToken(binding: ValueToken): PathNode {
   /** Expand a token into it's path refs */
   function expandPath(token: Token) {
     switch (token.type) {
-      case 'modelRef':
+      case "modelRef":
         path.push(convertModelRefToken(token));
         break;
-      case 'identifier':
+      case "identifier":
         path.push(convertIdentifierToken(token));
         break;
-      case 'quoted_value':
+      case "quoted_value":
         path.push(convertQuotedValueToken(token));
         break;
-      case 'expression':
+      case "expression":
         path.push(convertExpressionToken(token));
         break;
-      case 'query':
+      case "query":
         path.push(convertQueryToken(token));
         break;
-      case 'concatenated':
+      case "concatenated":
         path.push(convertConcatenatedToken(token));
         break;
       default:
@@ -155,7 +155,7 @@ function convertModelRefToken(token: ModelRefToken): PathNode {
 
 /** Parse a binding using ebnf */
 export const parse: Parser = (path) => {
-  if (path === '') {
+  if (path === "") {
     return {
       status: true,
       path: toPath([]),
@@ -167,12 +167,11 @@ export const parse: Parser = (path) => {
   if (!ast) {
     return {
       status: false,
-      error: 'Unable to parse binding',
+      error: "Unable to parse binding",
     };
   }
 
   if (ast.errors.length > 0) {
-    // console.log(ast.errors);
     return {
       status: false,
       error: ast.errors[0].message,

package/src/binding-grammar/ebnf/types.ts

@@ -1,8 +1,8 @@
-import type { IToken } from 'ebnf';
+import type { IToken } from "ebnf";
 
 export interface ValueToken extends IToken {
   /** A value type  */
-  type: 'value';
+  type: "value";
 
   /** Any children of the value */
   children: Array<SegmentAndBracketToken>;
@@ -10,7 +10,7 @@ export interface ValueToken extends IToken {
 
 export interface SegmentAndBracketToken extends IToken {
   /** A token for a segment + brackets */
-  type: 'segment_and_bracket';
+  type: "segment_and_bracket";
 
   /** The segment + brackets */
   children: [SegmentToken, ...Array<BracketToken>];
@@ -18,7 +18,7 @@ export interface SegmentAndBracketToken extends IToken {
 
 export interface SegmentToken extends IToken {
   /** A segment token */
-  type: 'segment';
+  type: "segment";
 
   /** Any children of the token */
   children: [ConcatenatedToken | IdentifierToken];
@@ -26,14 +26,14 @@ export interface SegmentToken extends IToken {
 
 export interface BracketToken extends IToken {
   /** A bracket token */
-  type: 'bracket';
+  type: "bracket";
   /** Any children of the token */
   children: [OptionallyQuotedSegment | QueryToken];
 }
 
 export interface ExpressionValueToken extends IToken {
   /** Expression value token */
-  type: 'expression_value';
+  type: "expression_value";
 
   /** No children here */
   children: [];
@@ -41,7 +41,7 @@ export interface ExpressionValueToken extends IToken {
 
 export interface ExpressionToken extends IToken {
   /** Expression token */
-  type: 'expression';
+  type: "expression";
 
   /** Children is the expression value */
   children: [ExpressionValueToken];
@@ -49,42 +49,42 @@ export interface ExpressionToken extends IToken {
 
 export interface QuotedValueToken extends IToken {
   /** A quoted value */
-  type: 'quoted_value';
+  type: "quoted_value";
   /** Any children of the token */
   children: [];
 }
 
 export interface IdentifierToken extends IToken {
   /** Any identifier */
-  type: 'identifier';
+  type: "identifier";
   /** Any children of the token */
   children: [];
 }
 
 export interface ConcatenatedToken extends IToken {
   /** A node of more than 1 identifier */
-  type: 'concatenated';
+  type: "concatenated";
   /** Any children of the token */
   children: Array<IdentifierToken | ModelRefToken | ExpressionToken>;
 }
 
 export interface ModelRefToken extends IToken {
   /** A nested model reference */
-  type: 'modelRef';
+  type: "modelRef";
   /** Any children of the token */
   children: [ValueToken];
 }
 
 export interface OptionallyQuotedSegment extends IToken {
   /** Any optionally quoted segment */
-  type: 'optionally_quoted_segment';
+  type: "optionally_quoted_segment";
   /** Any children of the token */
   children: [QuotedValueToken | SegmentToken];
 }
 
 export interface QueryToken extends IToken {
   /** A query */
-  type: 'query';
+  type: "query";
   /** Any children of the token */
   children: [OptionallyQuotedSegment, OptionallyQuotedSegment];
 }

package/src/binding-grammar/index.ts

@@ -1,4 +1,4 @@
-export * from './ast';
-export { parse as parseParsimmon } from './parsimmon';
-export { parse as parseEBNF } from './ebnf';
-export { parse as parseCustom } from './custom';
+export * from "./ast";
+export { parse as parseParsimmon } from "./parsimmon";
+export { parse as parseEBNF } from "./ebnf";
+export { parse as parseCustom } from "./custom";

package/src/binding-grammar/parsimmon/index.ts

@@ -1,21 +1,21 @@
-import flatten from 'arr-flatten';
-import type { Parser } from 'parsimmon';
-import P from 'parsimmon';
-import type { Parser as BindingParser } from '../ast';
+import flatten from "arr-flatten";
+import type { Parser } from "parsimmon";
+import P from "parsimmon";
+import type { Parser as BindingParser } from "../ast";
 import {
   toValue,
   toConcatenatedNode,
   toQuery,
   toPath,
   toExpression,
-} from '../ast';
+} from "../ast";
 
 const doubleQuote = P.string('"');
 const singleQuote = P.string("'");
-const backTick = P.string('`');
+const backTick = P.string("`");
 
 const identifier = P.regex(/[\w\-@]+/)
-  .desc('identifier')
+  .desc("identifier")
   .map(toValue);
 
 // eslint-disable-next-line prefer-const
@@ -24,7 +24,7 @@ let path: Parser<any>;
 const futurePath = P.lazy(() => path);
 const nestedPath = futurePath
   .trim(P.optWhitespace)
-  .wrap(P.string('{{'), P.string('}}'))
+  .wrap(P.string("{{"), P.string("}}"))
   .map(toPath);
 
 const nestedExpression = P.regex(/[^`]*/)
@@ -39,23 +39,23 @@ const segment = P.alt(identifier, nestedPath, nestedExpression)
 const optionallyQuotedSegment = P.alt(
   P.regex(/[^"]*/).wrap(doubleQuote, doubleQuote).map(toValue),
   P.regex(/[^']*/).wrap(singleQuote, singleQuote).map(toValue),
-  segment
+  segment,
 );
 
 const query = P.seq(
   optionallyQuotedSegment,
-  P.string('=').times(1, 3).trim(P.optWhitespace),
-  optionallyQuotedSegment
+  P.string("=").times(1, 3).trim(P.optWhitespace),
+  optionallyQuotedSegment,
 ).map(([key, , value]) => toQuery(key as any, value as any));
 
 const brackets = P.alt(query, optionallyQuotedSegment)
   .trim(P.optWhitespace)
-  .wrap(P.string('['), P.string(']'))
+  .wrap(P.string("["), P.string("]"))
   .many();
 
 const segmentAndBrackets = P.seqMap(segment, brackets, (s, bs) => [s, ...bs]);
 
-path = P.sepBy(segmentAndBrackets, P.string('.')).map(flatten);
+path = P.sepBy(segmentAndBrackets, P.string(".")).map(flatten);
 
 /** Parse a binding using parsimmon */
 export const parse: BindingParser = (binding) => {
@@ -65,7 +65,7 @@ export const parse: BindingParser = (binding) => {
     return {
       status: true,
       path: {
-        name: 'PathNode',
+        name: "PathNode",
         path: result.value,
       },
     };

package/src/controllers/constants/__tests__/index.test.ts

@@ -0,0 +1,106 @@
+import { test, expect } from "vitest";
+import { ConstantsController } from "..";
+
+test("basic get/set functionality", () => {
+  const controller = new ConstantsController();
+
+  // Basic get/set tests
+  const data = {
+    firstname: "john",
+    lastname: "doe",
+    favorite: {
+      color: "red",
+    },
+  };
+  controller.addConstants(data, "constants");
+
+  const firstname = controller.getConstants("firstname", "constants");
+  const middleName = controller.getConstants("middlename", "constants");
+  const middleNameSafe = controller.getConstants(
+    "middlename",
+    "constants",
+    "A",
+  );
+  const favoriteColor = controller.getConstants("favorite.color", "constants");
+  const nonExistantNamespace = controller.getConstants("test", "foo");
+  const nonExistantNamespaceWithFallback = controller.getConstants(
+    "test",
+    "foo",
+    "bar",
+  );
+
+  expect(firstname).toStrictEqual(data.firstname);
+  expect(middleName).toBe(undefined);
+  expect(middleNameSafe).toStrictEqual("A");
+  expect(favoriteColor).toStrictEqual(data.favorite.color);
+  expect(favoriteColor).toStrictEqual(data.favorite.color);
+  expect(nonExistantNamespace).toBe(undefined);
+  expect(nonExistantNamespaceWithFallback).toBe("bar");
+
+  // Test and make sure keys override properly
+  const newData = {
+    favorite: {
+      color: "blue",
+    },
+  };
+
+  controller.addConstants(newData, "constants");
+  const newFavoriteColor = controller.getConstants(
+    "favorite.color",
+    "constants",
+  );
+  expect(newFavoriteColor).toStrictEqual(newData.favorite.color);
+});
+
+test("temp override functionality", () => {
+  const controller = new ConstantsController();
+
+  // Basic Temp tests
+  const data = {
+    firstname: "john",
+    lastname: "doe",
+    favorite: {
+      color: "red",
+    },
+  };
+
+  const temp = {
+    middlename: "A",
+    favorite: {
+      color: "green",
+    },
+  };
+  controller.addConstants(data, "constants");
+  controller.setTemporaryValues(temp, "constants");
+
+  const tempMiddleName = controller.getConstants("middlename", "constants");
+  const tempFavoriteColor = controller.getConstants(
+    "favorite.color",
+    "constants",
+  );
+
+  expect(tempMiddleName).toStrictEqual(temp.middlename);
+  expect(tempFavoriteColor).toStrictEqual(temp.favorite.color);
+
+  // Test overriding temp with new temp
+  const newTemp = {
+    favorite: {
+      color: "orange",
+    },
+  };
+  controller.setTemporaryValues(newTemp, "constants");
+  const newtempFavoriteColor = controller.getConstants(
+    "favorite.color",
+    "constants",
+  );
+  expect(newtempFavoriteColor).toStrictEqual(newTemp.favorite.color);
+
+  // Reset temp and values should be the same as the original data
+  controller.clearTemporaryValues();
+
+  const middleName = controller.getConstants("middlename", "constants");
+  const favoriteColor = controller.getConstants("favorite.color", "constants");
+
+  expect(middleName).toBe(undefined);
+  expect(favoriteColor).toStrictEqual(data.favorite.color);
+});

package/src/controllers/constants/index.ts

@@ -1,6 +1,6 @@
-import { LocalModel } from '../../data';
-import { BindingInstance } from '../../binding';
-import { objectToBatchSet } from './utils';
+import { LocalModel } from "../../data";
+import { BindingInstance } from "../../binding";
+import { objectToBatchSet } from "./utils";
 
 export interface ConstantsProvider {
   /**

package/src/controllers/constants/utils.ts

@@ -1,7 +1,7 @@
-import { BindingInstance } from '../../binding';
+import { BindingInstance } from "../../binding";
 
 /** Recursively flattens a nested object to be an object of depth 1 with keys being the full path in the orginal object */
-export function flatten(obj: any, roots: [string][] = [], sep = '.'): any {
+export function flatten(obj: any, roots: [string][] = [], sep = "."): any {
   return (
     Object
       // find props of given object
@@ -13,13 +13,13 @@ export function flatten(obj: any, roots: [string][] = [], sep = '.'): any {
 
           // include previously returned object
           ...memo,
-          ...(Object.prototype.toString.call(obj[prop]) === '[object Object]'
+          ...(Object.prototype.toString.call(obj[prop]) === "[object Object]"
             ? // keep working if value is an object
               flatten(obj[prop], roots.concat([prop]))
             : // include current prop and value and prefix prop with the roots
               { [roots.concat([prop]).join(sep)]: obj[prop] }),
         }),
-        {}
+        {},
       )
   );
 }

package/src/controllers/data/controller.ts

@@ -1,8 +1,8 @@
-import { SyncHook, SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
-import { dequal } from 'dequal';
-import type { Logger } from '../../logger';
-import type { BindingParser, BindingLike } from '../../binding';
-import { BindingInstance } from '../../binding';
+import { SyncHook, SyncWaterfallHook, SyncBailHook } from "tapable-ts";
+import { dequal } from "dequal";
+import type { Logger } from "../../logger";
+import type { BindingParser, BindingLike } from "../../binding";
+import { BindingInstance } from "../../binding";
 import type {
   BatchSetTransaction,
   Updates,
@@ -10,10 +10,10 @@ import type {
   DataModelWithParser,
   DataPipeline,
   DataModelMiddleware,
-} from '../../data';
-import { PipelinedDataModel, LocalModel } from '../../data';
-import type { RawSetTransaction } from '../../types';
-import { ReadOnlyDataController } from './utils';
+} from "../../data";
+import { PipelinedDataModel, LocalModel } from "../../data";
+import type { RawSetTransaction } from "../../types";
+import { ReadOnlyDataController } from "./utils";
 
 /** The orchestrator for player data */
 export class DataController implements DataModelWithParser<DataModelOptions> {
@@ -56,7 +56,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
 
       /** A logger to use  */
       logger?: Logger;
-    }
+    },
   ) {
     this.logger = options.logger;
     const middleware = options.middleware || [];
@@ -80,7 +80,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
   private resolveDataValue(
     binding: BindingInstance,
     value: any,
-    deformat: boolean
+    deformat: boolean,
   ) {
     if (deformat) {
       return this.hooks.deformat.call(value, binding);
@@ -91,7 +91,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
 
   public set(
     transaction: RawSetTransaction,
-    options?: DataModelOptions
+    options?: DataModelOptions,
   ): Updates {
     let normalizedTransaction: BatchSetTransaction = [];
 
@@ -114,7 +114,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
             parsed,
             this.resolveDataValue(parsed, val, Boolean(options?.formatted)),
           ];
-        }
+        },
       ) as BatchSetTransaction;
     }
 
@@ -131,19 +131,19 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
 
         if (dequal(oldVal, newVal)) {
           this.logger?.debug(
-            `Skipping update for path: ${binding.asString()}. Value was unchanged: ${oldVal}`
+            `Skipping update for path: ${binding.asString()}. Value was unchanged: ${oldVal}`,
           );
         } else {
           updates.push(update);
 
           this.logger?.debug(
-            `Setting path: ${binding.asString()} from: ${oldVal} to: ${newVal}`
+            `Setting path: ${binding.asString()} from: ${oldVal} to: ${newVal}`,
           );
         }
 
         return updates;
       },
-      []
+      [],
     );
 
     // Get the applied update
@@ -159,7 +159,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
         this.logger?.debug(
           `Path: ${tr.binding.asString()} was changed from: ${
             tr.oldValue
-          } to: ${tr.newValue}`
+          } to: ${tr.newValue}`,
         );
         setUpdates.push(tr);
       }
@@ -175,7 +175,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
   }
 
   private resolve(binding: BindingLike, readOnly: boolean): BindingInstance {
-    return Array.isArray(binding) || typeof binding === 'string'
+    return Array.isArray(binding) || typeof binding === "string"
       ? this.pathResolver.parse(binding, { readOnly })
       : binding;
   }
@@ -208,11 +208,11 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
 
   public delete(binding: BindingLike, options?: DataModelOptions) {
     if (
-      typeof binding !== 'string' &&
+      typeof binding !== "string" &&
       !Array.isArray(binding) &&
       !(binding instanceof BindingInstance)
     ) {
-      throw new Error('Invalid arguments: delete expects a data path (string)');
+      throw new Error("Invalid arguments: delete expects a data path (string)");
     }
 
     const resolved =
@@ -225,7 +225,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
     const parentValue = this.get(parentBinding);
 
     const existedBeforeDelete =
-      typeof parentValue === 'object' &&
+      typeof parentValue === "object" &&
       parentValue !== null &&
       Object.prototype.hasOwnProperty.call(parentValue, property);
 
@@ -239,7 +239,7 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
   }
 
   public serialize(): object {
-    return this.hooks.serialize.call(this.get(''));
+    return this.hooks.serialize.call(this.get(""));
   }
 
   public makeReadOnly(): ReadOnlyDataController {

package/src/controllers/data/index.ts

@@ -1 +1 @@
-export * from './controller';
+export * from "./controller";

package/src/controllers/data/utils.ts

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import type { DataController } from '.';
-import type { Logger } from '../../logger';
-import type { BindingLike } from '../../binding';
+import type { DataController } from ".";
+import type { Logger } from "../../logger";
+import type { BindingLike } from "../../binding";
 import type {
   DataModelWithParser,
   DataModelOptions,
   Updates,
-} from '../../data';
+} from "../../data";
 
 /** Wrapper for the Data Controller Class that prevents writes */
 export class ReadOnlyDataController
@@ -26,17 +26,17 @@ export class ReadOnlyDataController
 
   set(
     transaction: [BindingLike, any][],
-    options?: DataModelOptions | undefined
+    options?: DataModelOptions | undefined,
   ): Updates {
     this.logger?.error(
-      'Error: Tried to set in a read only instance of the DataController'
+      "Error: Tried to set in a read only instance of the DataController",
     );
     return [];
   }
 
   delete(binding: BindingLike, options?: DataModelOptions | undefined): void {
     this.logger?.error(
-      'Error: Tried to delete in a read only instance of the DataController'
+      "Error: Tried to delete in a read only instance of the DataController",
     );
   }
 }