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

package/src/types.ts

@@ -1,22 +1,22 @@
-import type { Flow, FlowResult } from '@player-ui/types';
-import type { BindingParser, BindingLike } from './binding';
-import type { SchemaController } from './schema';
-import type { ExpressionEvaluator } from './expressions';
-import type { Logger } from './logger';
+import type { Flow, FlowResult } from "@player-ui/types";
+import type { BindingParser, BindingLike } from "./binding";
+import type { SchemaController } from "./schema";
+import type { ExpressionEvaluator } from "./expressions";
+import type { Logger } from "./logger";
 import type {
   ViewController,
   DataController,
   ValidationController,
   FlowController,
-} from './controllers';
-import type { ReadOnlyDataController } from './controllers/data/utils';
+} from "./controllers";
+import type { ReadOnlyDataController } from "./controllers/data/utils";
 
 /** The status for a flow's execution state */
 export type PlayerFlowStatus =
-  | 'not-started'
-  | 'in-progress'
-  | 'completed'
-  | 'error';
+  | "not-started"
+  | "in-progress"
+  | "completed"
+  | "error";
 
 /** Common interface for the state of Player's flow execution */
 export interface BaseFlowState<T extends PlayerFlowStatus> {
@@ -28,11 +28,11 @@ export interface BaseFlowState<T extends PlayerFlowStatus> {
 }
 
 /** The beginning state of Player, before it's seen a flow  */
-export type NotStartedState = BaseFlowState<'not-started'>;
+export type NotStartedState = BaseFlowState<"not-started">;
 
 export const NOT_STARTED_STATE: NotStartedState = {
-  ref: Symbol('not-started'),
-  status: 'not-started',
+  ref: Symbol("not-started"),
+  status: "not-started",
 };
 
 /** Shared properties for a flow in any state of execution (in-progress, completed successfully, or errored out) */
@@ -65,7 +65,7 @@ export interface ControllerState {
 }
 
 /** A flow is currently executing */
-export type InProgressState = BaseFlowState<'in-progress'> &
+export type InProgressState = BaseFlowState<"in-progress"> &
   PlayerFlowExecutionData & {
     /** A promise that resolves when the flow is completed */
     flowResult: Promise<FlowResult>;
@@ -83,7 +83,7 @@ export type InProgressState = BaseFlowState<'in-progress'> &
   };
 
 /** The flow completed properly */
-export type CompletedState = BaseFlowState<'completed'> &
+export type CompletedState = BaseFlowState<"completed"> &
   PlayerFlowExecutionData &
   FlowResult & {
     /** Readonly Player controllers to provide Player functionality after the flow has ended */
@@ -94,7 +94,7 @@ export type CompletedState = BaseFlowState<'completed'> &
   };
 
 /** The flow finished but not successfully */
-export type ErrorState = BaseFlowState<'error'> & {
+export type ErrorState = BaseFlowState<"error"> & {
   /** The currently executing flow */
   flow: Flow;
 

package/src/utils/__tests__/replaceParams.test.ts

@@ -0,0 +1,33 @@
+import { describe, test, expect } from "vitest";
+import { replaceParams } from "..";
+
+describe("Replace Params", () => {
+  test("should replace strings correctly", () => {
+    const actual = replaceParams(
+      "The desired length of this field is %desiredLength. The current length is %currentLength.",
+      { desiredLength: 5, currentLength: 10 },
+    );
+    const expected =
+      "The desired length of this field is 5. The current length is 10.";
+    expect(actual).toBe(expected);
+  });
+
+  test("do not replace strings for no match", () => {
+    const actual = replaceParams(
+      "The desired length of this field is %desiredLength. The current length is %currentLength.",
+      { desiredLength: 5 },
+    );
+    const expected =
+      "The desired length of this field is 5. The current length is %currentLength.";
+    expect(actual).toBe(expected);
+  });
+
+  test("do not replace strings for no templates", () => {
+    const actual = replaceParams(
+      "No template in this string. Ignore parameters",
+      { desiredLength: 5, currentLength: 10 },
+    );
+    const expected = "No template in this string. Ignore parameters";
+    expect(actual).toBe(expected);
+  });
+});

package/src/utils/index.ts

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

package/src/utils/replaceParams.ts

@@ -9,7 +9,7 @@ const ANY_CHAR_REGEX = /%([a-zA-Z]+)/g;
  */
 export function replaceParams(
   message: string,
-  params: Record<string, any>
+  params: Record<string, any>,
 ): string {
   return message
     .slice()

package/src/validator/__tests__/binding-map-splice.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from "vitest";
+import { BindingParser } from "../../binding";
+import { removeBindingAndChildrenFromMap } from "../binding-map-splice";
+
+const parser = new BindingParser({
+  get: () => undefined,
+  set: () => undefined,
+  evaluate: () => undefined,
+});
+
+describe("removeBindingAndChildrenFromMap", () => {
+  it("removes a binding and its chidlren", () => {
+    const sourceMap = new Map([
+      [parser.parse("foo.bar.baz"), 1],
+      [parser.parse("foo.bar"), 2],
+      [parser.parse("foo.baz"), 3],
+    ]);
+
+    const result = removeBindingAndChildrenFromMap(
+      sourceMap,
+      parser.parse("foo.bar"),
+    );
+
+    expect(result).toStrictEqual(new Map([[parser.parse("foo.baz"), 3]]));
+  });
+
+  it("splices a binding and its children", () => {
+    const sourceMap = new Map([
+      [parser.parse("foo.bar.0.aaa"), 1],
+      [parser.parse("foo.bar.0.aab"), 2],
+      [parser.parse("foo.bar.1.bba"), 3],
+      [parser.parse("foo.bar.1.bbb"), 4],
+      [parser.parse("foo.bar.2.cca"), 5],
+      [parser.parse("foo.bar.2.ccb"), 6],
+      [parser.parse("foo.baz"), 3],
+    ]);
+
+    const result = removeBindingAndChildrenFromMap(
+      sourceMap,
+      parser.parse("foo.bar.1"),
+    );
+
+    expect(result).toStrictEqual(
+      new Map([
+        [parser.parse("foo.bar.0.aaa"), 1],
+        [parser.parse("foo.bar.0.aab"), 2],
+        [parser.parse("foo.bar.1.cca"), 5],
+        [parser.parse("foo.bar.1.ccb"), 6],
+        [parser.parse("foo.baz"), 3],
+      ]),
+    );
+  });
+});

package/src/validator/__tests__/validation-middleware.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, test, beforeEach } from "vitest";
+import { BindingParser } from "../../binding";
+import type { DataModelImpl } from "../../data";
+import { PipelinedDataModel, LocalModel } from "../../data";
+import type { MiddlewareChecker } from "..";
+import { ValidationMiddleware } from "..";
+
+const parser = new BindingParser({
+  get: () => undefined,
+  set: () => undefined,
+  evaluate: () => undefined,
+});
+const foo = parser.parse("foo");
+const bar = parser.parse("bar");
+
+describe("middleware", () => {
+  /**
+   * a sample validator that checks for non-vaz values.
+   */
+  const validator: MiddlewareChecker = (binding, model) => {
+    if (model.get(binding) === "baz") {
+      return {
+        severity: "error",
+        message: "Wrong Value",
+      };
+    }
+  };
+
+  let baseDataModel: DataModelImpl;
+  let dataModelWithMiddleware: ValidationMiddleware;
+
+  beforeEach(() => {
+    baseDataModel = new LocalModel();
+    dataModelWithMiddleware = new ValidationMiddleware(validator);
+  });
+
+  it("allows valid data to fall through", () => {
+    // Any valid value should fall through
+    dataModelWithMiddleware.set([[foo, "bar"]], undefined, baseDataModel);
+    expect(
+      dataModelWithMiddleware.get(foo, undefined, baseDataModel),
+    ).toStrictEqual("bar");
+    expect(baseDataModel.get(foo)).toStrictEqual("bar");
+  });
+
+  it("catches invalid data", () => {
+    // Any invalid data should stay in the middleware's cache
+    dataModelWithMiddleware.set([[foo, "bar"]], undefined, baseDataModel);
+    dataModelWithMiddleware.set([[foo, "baz"]], undefined, baseDataModel);
+    expect(
+      dataModelWithMiddleware.get(foo, { includeInvalid: true }, baseDataModel),
+    ).toStrictEqual("baz");
+    expect(baseDataModel.get(foo)).toStrictEqual("bar");
+  });
+
+  it("only returns updates for bindings set in the same transaction", () => {
+    // Setup the invalid data
+    const invalidUpdates = dataModelWithMiddleware.set(
+      [[foo, "baz"]],
+      undefined,
+      baseDataModel,
+    );
+
+    expect(invalidUpdates).toMatchInlineSnapshot(`
+      [
+        {
+          "binding": BindingInstance {
+            "factory": [Function],
+            "joined": "foo",
+            "split": [
+              "foo",
+            ],
+          },
+          "force": true,
+          "newValue": "baz",
+          "oldValue": "baz",
+        },
+      ]
+    `);
+
+    // Set some unrelated data
+    const validUpdates = dataModelWithMiddleware.set(
+      [[bar, "baz"]],
+      undefined,
+      baseDataModel,
+    );
+
+    expect(validUpdates).toHaveLength(1);
+  });
+});
+
+test("merges invalid", () => {
+  const model = new PipelinedDataModel([
+    new LocalModel({
+      valid: true,
+      invalid: false,
+    }),
+    new ValidationMiddleware((binding, validationModel) => {
+      if (
+        binding.asString() === "invalid" &&
+        validationModel.get(binding) !== false
+      ) {
+        return {
+          severity: "error",
+          message: "Nope",
+        };
+      }
+    }),
+  ]);
+
+  expect(model.get(parser.parse(""))).toStrictEqual({
+    valid: true,
+    invalid: false,
+  });
+
+  model.set([[parser.parse("invalid"), true]]);
+
+  expect(model.get(parser.parse(""), { includeInvalid: false })).toStrictEqual({
+    valid: true,
+    invalid: false,
+  });
+
+  expect(model.get(parser.parse(""), { includeInvalid: true })).toStrictEqual({
+    valid: true,
+    invalid: true,
+  });
+});

package/src/validator/binding-map-splice.ts

@@ -1,4 +1,4 @@
-import type { BindingInstance } from '../binding';
+import type { BindingInstance } from "../binding";
 
 /**
  * Remove a binding, and any children from from the map
@@ -9,7 +9,7 @@ import type { BindingInstance } from '../binding';
  */
 export function removeBindingAndChildrenFromMap<T>(
   sourceMap: Map<BindingInstance, T>,
-  binding: BindingInstance
+  binding: BindingInstance,
 ): Map<BindingInstance, T> {
   const targetMap = new Map(sourceMap);
 
@@ -24,7 +24,7 @@ export function removeBindingAndChildrenFromMap<T>(
     }
   });
 
-  if (typeof property === 'number') {
+  if (typeof property === "number") {
     // Splice out this index from the rest
 
     // Order matters here b/c we are shifting items in the array
@@ -33,7 +33,7 @@ export function removeBindingAndChildrenFromMap<T>(
       .filter((b) => {
         if (parentBinding.contains(b)) {
           const [childIndex] = b.relative(parentBinding);
-          return typeof childIndex === 'number' && childIndex > property;
+          return typeof childIndex === "number" && childIndex > property;
         }
 
         return false;
@@ -46,7 +46,7 @@ export function removeBindingAndChildrenFromMap<T>(
 
       const [childIndex, ...childPath] = trackedBinding.relative(parentBinding);
 
-      if (typeof childIndex === 'number') {
+      if (typeof childIndex === "number") {
         const newSegments = [childIndex - 1, ...childPath];
         const newChildBinding = parentBinding.descendent(newSegments);
         targetMap.set(newChildBinding, targetMap.get(trackedBinding) as T);

package/src/validator/index.ts

@@ -1,4 +1,4 @@
-export * from './validation-middleware';
-export * from './types';
-export * from './registry';
-export * from './binding-map-splice';
+export * from "./validation-middleware";
+export * from "./types";
+export * from "./registry";
+export * from "./binding-map-splice";

package/src/validator/registry.ts

@@ -1,4 +1,4 @@
-import type { ValidatorFunction } from './types';
+import type { ValidatorFunction } from "./types";
 
 /** A registry that tracks validators  */
 export class ValidatorRegistry {

package/src/validator/types.ts

@@ -1,10 +1,10 @@
-import type { Schema, Validation } from '@player-ui/types';
+import type { Schema, Validation } from "@player-ui/types";
 
-import type { BindingInstance, BindingFactory } from '../binding';
-import type { DataModelWithParser } from '../data';
-import type { ExpressionEvaluatorFunction } from '../expressions';
-import type { Logger } from '../logger';
-import type { ConstantsProvider } from '../controllers';
+import type { BindingInstance, BindingFactory } from "../binding";
+import type { DataModelWithParser } from "../data";
+import type { ExpressionEvaluatorFunction } from "../expressions";
+import type { Logger } from "../logger";
+import type { ConstantsProvider } from "../controllers";
 
 interface BaseValidationResponse<T = Validation.Severity> {
   /** The validation message to show to the user */
@@ -20,22 +20,22 @@ interface BaseValidationResponse<T = Validation.Severity> {
   displayTarget?: Validation.DisplayTarget;
 
   /** The blocking state of this validation */
-  blocking?: boolean | 'once';
+  blocking?: boolean | "once";
 }
 
 export interface WarningValidationResponse
-  extends BaseValidationResponse<'warning'> {
+  extends BaseValidationResponse<"warning"> {
   /** Warning validations can be dismissed without correcting the error */
   dismiss?: () => void;
 }
 
-export type ErrorValidationResponse = BaseValidationResponse<'error'>;
+export type ErrorValidationResponse = BaseValidationResponse<"error">;
 
 export type ValidationResponse =
   | ErrorValidationResponse
   | WarningValidationResponse;
 
-type RequiredValidationKeys = 'severity' | 'trigger';
+type RequiredValidationKeys = "severity" | "trigger";
 
 export type ValidationObject = Validation.Reference &
   Required<Pick<Validation.Reference, RequiredValidationKeys>>;
@@ -47,7 +47,7 @@ export type ValidationObjectWithHandler = ValidationObject & {
 
 export interface ValidationProvider {
   getValidationsForBinding?(
-    binding: BindingInstance
+    binding: BindingInstance,
   ): Array<ValidationObjectWithHandler> | undefined;
 
   getValidationsForView?(): Array<ValidationObjectWithHandler> | undefined;
@@ -79,5 +79,5 @@ export interface ValidatorContext {
 export type ValidatorFunction<Options = unknown> = (
   context: ValidatorContext,
   value: any,
-  options?: Options
-) => Omit<BaseValidationResponse, 'severity'> | undefined;
+  options?: Options,
+) => Omit<BaseValidationResponse, "severity"> | undefined;

package/src/validator/validation-middleware.ts

@@ -1,17 +1,17 @@
-import { setIn } from 'timm';
-import type { BindingInstance } from '../binding';
+import { setIn } from "timm";
+import type { BindingInstance } from "../binding";
 import type {
   BatchSetTransaction,
   DataModelImpl,
   DataModelOptions,
   DataModelMiddleware,
   Updates,
-} from '../data';
-import { toModel } from '../data';
-import type { Logger } from '../logger';
+} from "../data";
+import { toModel } from "../data";
+import type { Logger } from "../logger";
 
-import type { ValidationResponse } from './types';
-import { removeBindingAndChildrenFromMap } from './binding-map-splice';
+import type { ValidationResponse } from "./types";
+import { removeBindingAndChildrenFromMap } from "./binding-map-splice";
 
 /**
  * A BindingInstance with an indicator of whether or not it's a strong binding
@@ -28,7 +28,7 @@ export type StrongOrWeakBinding = {
  */
 export type MiddlewareChecker = (
   binding: BindingInstance,
-  model: DataModelImpl
+  model: DataModelImpl,
 ) => ValidationResponse | Set<StrongOrWeakBinding> | undefined;
 
 /**
@@ -47,7 +47,7 @@ export class ValidationMiddleware implements DataModelMiddleware {
       logger?: Logger;
       /** Optional function to include data staged in shadowModel */
       shouldIncludeInvalid?: (options?: DataModelOptions) => boolean;
-    }
+    },
   ) {
     this.validator = validator;
     this.shadowModelPaths = new Map();
@@ -58,7 +58,7 @@ export class ValidationMiddleware implements DataModelMiddleware {
   public set(
     transaction: BatchSetTransaction,
     options?: DataModelOptions,
-    next?: DataModelImpl
+    next?: DataModelImpl,
   ): Updates {
     const asModel = toModel(this, { ...options, includeInvalid: true }, next);
     const nextTransaction: BatchSetTransaction = [];
@@ -92,7 +92,7 @@ export class ValidationMiddleware implements DataModelMiddleware {
         this.logger?.debug(
           `Invalid value for path: ${binding.asString()} - ${
             validations.severity
-          } - ${validations.message}`
+          } - ${validations.message}`,
         );
       }
     });
@@ -102,7 +102,7 @@ export class ValidationMiddleware implements DataModelMiddleware {
     if (next && nextTransaction.length > 0) {
       // defer clearing the shadow model to prevent validations that are run twice due to weak binding refs still needing the data
       nextTransaction.forEach(([binding]) =>
-        this.shadowModelPaths.delete(binding)
+        this.shadowModelPaths.delete(binding),
       );
       const result = next.set(nextTransaction, options);
       if (invalidBindings.length === 0) {
@@ -127,7 +127,7 @@ export class ValidationMiddleware implements DataModelMiddleware {
   public get(
     binding: BindingInstance,
     options?: DataModelOptions,
-    next?: DataModelImpl
+    next?: DataModelImpl,
   ) {
     let val = next?.get(binding, options);
 
@@ -154,11 +154,11 @@ export class ValidationMiddleware implements DataModelMiddleware {
   public delete(
     binding: BindingInstance,
     options?: DataModelOptions,
-    next?: DataModelImpl
+    next?: DataModelImpl,
   ) {
     this.shadowModelPaths = removeBindingAndChildrenFromMap(
       this.shadowModelPaths,
-      binding
+      binding,
     );
 
     return next?.delete(binding, options);