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

package/src/controllers/view/asset-transform.ts

@@ -1,8 +1,8 @@
-import type { Node } from '../../view';
-import { NodeType } from '../../view';
-import { LocalStateStore } from './store';
-import type { TransformRegistry } from './types';
-import type { ViewController } from './controller';
+import type { Node } from "../../view";
+import { NodeType } from "../../view";
+import { LocalStateStore } from "./store";
+import type { TransformRegistry } from "./types";
+import type { ViewController } from "./controller";
 
 /** Traverse up the nodes until the target is found */
 function findUp(node: Node.Node, target: Node.Node): boolean {
@@ -32,18 +32,18 @@ export class AssetTransformCorePlugin {
   constructor(registry: TransformRegistry) {
     this.registry = registry;
     this.stateStore = new Map();
-    this.beforeResolveSymbol = Symbol('before resolve');
-    this.resolveSymbol = Symbol('resolve');
-    this.beforeResolveCountSymbol = Symbol('before resolve count');
-    this.resolveCountSymbol = Symbol('resolve count');
+    this.beforeResolveSymbol = Symbol("before resolve");
+    this.resolveSymbol = Symbol("resolve");
+    this.beforeResolveCountSymbol = Symbol("before resolve count");
+    this.resolveCountSymbol = Symbol("resolve count");
   }
 
   apply(viewController: ViewController) {
-    viewController.hooks.view.tap('asset-transform', (view) => {
+    viewController.hooks.view.tap("asset-transform", (view) => {
       // Clear out everything when we create a new view
       this.stateStore.clear();
 
-      view.hooks.resolver.tap('asset-transform', (resolver) => {
+      view.hooks.resolver.tap("asset-transform", (resolver) => {
         let lastUpdatedNode: Node.Node | undefined;
 
         /** A function to update the state and trigger a view re-compute */
@@ -74,27 +74,27 @@ export class AssetTransformCorePlugin {
 
           return {
             useSharedState: (
-              key: string | symbol
+              key: string | symbol,
             ): (<T>(initialState: T) => readonly [T, (value: T) => void]) => {
               return store.useSharedState(key);
             },
             useLocalState: <T>(initialState: T) => {
               return store.getLocalStateFunction<T>(
                 stepKey,
-                countKey
+                countKey,
               )(initialState);
             },
           };
         };
 
-        resolver.hooks.beforeResolve.tap('asset-transform', (node, options) => {
-          if (node && (node.type === 'asset' || node.type === 'view')) {
+        resolver.hooks.beforeResolve.tap("asset-transform", (node, options) => {
+          if (node && (node.type === "asset" || node.type === "view")) {
             const transform = this.registry.get(node.value);
 
             if (transform?.beforeResolve) {
               const store = getStore(
                 options.node ?? node,
-                this.beforeResolveSymbol
+                this.beforeResolveSymbol,
               );
 
               return transform.beforeResolve(node, options, store);
@@ -104,11 +104,11 @@ export class AssetTransformCorePlugin {
           return node;
         });
 
-        resolver.hooks.afterUpdate.tap('asset-transform', () => {
+        resolver.hooks.afterUpdate.tap("asset-transform", () => {
           lastUpdatedNode = undefined;
         });
 
-        resolver.hooks.skipResolve.tap('asset-transform', (skip, node) => {
+        resolver.hooks.skipResolve.tap("asset-transform", (skip, node) => {
           if (!skip || !lastUpdatedNode) {
             return skip;
           }
@@ -120,7 +120,7 @@ export class AssetTransformCorePlugin {
         });
 
         resolver.hooks.afterResolve.tap(
-          'asset-transform',
+          "asset-transform",
           (value, node, options) => {
             if (node.type !== NodeType.Asset && node.type !== NodeType.View) {
               return value;
@@ -141,7 +141,7 @@ export class AssetTransformCorePlugin {
             }
 
             return value;
-          }
+          },
         );
       });
     });

package/src/controllers/view/controller.ts

@@ -1,17 +1,17 @@
-import { SyncHook, SyncWaterfallHook } from 'tapable-ts';
-import queueMicrotask from 'queue-microtask';
-import { Registry } from '@player-ui/partial-match-registry';
-import type { View, NavigationFlowViewState } from '@player-ui/types';
-
-import { resolveDataRefsInString } from '../../string-resolver';
-import type { Resolve } from '../../view';
-import { ViewInstance } from '../../view';
-import type { Logger } from '../../logger';
-import type { FlowInstance, FlowController } from '../flow';
-import type { DataController } from '../data/controller';
-import { AssetTransformCorePlugin } from './asset-transform';
-import type { TransformRegistry } from './types';
-import type { BindingInstance } from '../../binding';
+import { SyncHook, SyncWaterfallHook } from "tapable-ts";
+import queueMicrotask from "queue-microtask";
+import { Registry } from "@player-ui/partial-match-registry";
+import type { View, NavigationFlowViewState } from "@player-ui/types";
+
+import { resolveDataRefsInString } from "../../string-resolver";
+import type { Resolve } from "../../view";
+import { ViewInstance } from "../../view";
+import type { Logger } from "../../logger";
+import type { FlowInstance, FlowController } from "../flow";
+import type { DataController } from "../data/controller";
+import { AssetTransformCorePlugin } from "./asset-transform";
+import type { TransformRegistry } from "./types";
+import type { BindingInstance } from "../../binding";
 
 export interface ViewControllerOptions {
   /** Where to get data from */
@@ -51,7 +51,7 @@ export class ViewController {
 
   constructor(
     initialViews: View[],
-    options: Resolve.ResolverOptions & ViewControllerOptions
+    options: Resolve.ResolverOptions & ViewControllerOptions,
   ) {
     this.viewOptions = options;
     this.viewMap = initialViews.reduce<Record<string, View>>(
@@ -60,22 +60,22 @@ export class ViewController {
         viewMap[view.id] = view;
         return viewMap;
       },
-      {}
+      {},
     );
 
     new AssetTransformCorePlugin(this.transformRegistry).apply(this);
 
     options.flowController.hooks.flow.tap(
-      'viewController',
+      "viewController",
       (flow: FlowInstance) => {
-        flow.hooks.transition.tap('viewController', (_oldState, newState) => {
-          if (newState.value.state_type === 'VIEW') {
+        flow.hooks.transition.tap("viewController", (_oldState, newState) => {
+          if (newState.value.state_type === "VIEW") {
             this.onView(newState.value);
           } else {
             this.currentView = undefined;
           }
         });
-      }
+      },
     );
 
     /** Trigger a view update */
@@ -90,21 +90,21 @@ export class ViewController {
     };
 
     options.model.hooks.onUpdate.tap(
-      'viewController',
+      "viewController",
       (updates, updateOptions) => {
         update(
           new Set(updates.map((t) => t.binding)),
-          updateOptions?.silent ?? false
+          updateOptions?.silent ?? false,
         );
-      }
+      },
     );
 
-    options.model.hooks.onDelete.tap('viewController', (binding) => {
+    options.model.hooks.onDelete.tap("viewController", (binding) => {
       const parentBinding = binding.parent();
       const property = binding.key();
 
       // Deleting an array item will trigger an update for the entire array
-      if (typeof property === 'number' && parentBinding) {
+      if (typeof property === "number" && parentBinding) {
         update(new Set([parentBinding]));
       } else {
         update(new Set([binding]));
@@ -148,7 +148,7 @@ export class ViewController {
         resolveDataRefsInString(possibleViewIdMatch, {
           model: this.viewOptions.model,
           evaluate: this.viewOptions.evaluator.evaluate,
-        })
+        }),
     );
 
     if (matchingViewId && this.viewMap[matchingViewId]) {
@@ -162,7 +162,7 @@ export class ViewController {
     const source = this.hooks.resolveView.call(
       this.getViewForRef(viewId),
       viewId,
-      state
+      state,
     );
 
     if (!source) {

package/src/controllers/view/index.ts

@@ -1,4 +1,4 @@
-export * from './asset-transform';
-export * from './controller';
-export * from './store';
-export * from './types';
+export * from "./asset-transform";
+export * from "./controller";
+export * from "./store";
+export * from "./types";

package/src/controllers/view/store.ts

@@ -1,17 +1,17 @@
 export interface Store {
   useLocalState<T>(initialState: T): readonly [T, (value: T) => void];
   useSharedState<T>(
-    key: string | symbol
+    key: string | symbol,
   ): (initialState: T) => readonly [T, (value: T) => void];
 }
 
 interface SharedStore {
   getLocalStateFunction<T>(
     key: string | symbol,
-    countKey: symbol
+    countKey: symbol,
   ): (initialState: T) => readonly [T, (value: T) => void];
   useSharedState<T>(
-    key: string | symbol
+    key: string | symbol,
   ): (initialState: T) => readonly [T, (value: T) => void];
 }
 

package/src/controllers/view/types.ts

@@ -1,24 +1,24 @@
-import type { Asset } from '@player-ui/types';
-import type { Registry } from '@player-ui/partial-match-registry';
+import type { Asset } from "@player-ui/types";
+import type { Registry } from "@player-ui/partial-match-registry";
 
-import type { Resolve, Node } from '../../view';
-import type { Store } from './store';
+import type { Resolve, Node } from "../../view";
+import type { Store } from "./store";
 
 /** Transform function that is ran on the Asset before it's resolved */
 export type BeforeTransformFunction<AuthoredAsset extends Asset = Asset> = (
   asset: Node.Asset<AuthoredAsset> | Node.View<AuthoredAsset>,
   options: Resolve.NodeResolveOptions,
-  store: Store
+  store: Store,
 ) => Node.Node;
 
 /** Transform function that is ran on the Asset after it's resolved */
 export type TransformFunction<
   AuthoredAsset extends Asset = Asset,
-  TransformedAsset extends Asset = AuthoredAsset
+  TransformedAsset extends Asset = AuthoredAsset,
 > = (
   asset: AuthoredAsset,
   options: Resolve.NodeResolveOptions,
-  store: Store
+  store: Store,
 ) => TransformedAsset;
 
 export interface TransformFunctions {

package/src/data/__tests__/__snapshots__/dependency-tracker.test.ts.snap

@@ -0,0 +1,64 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`dependency model > tracks dependency sets correctly 1`] = `
+Set {
+  BindingInstance {
+    "factory": [Function],
+    "joined": "foo.bar",
+    "split": [
+      "foo",
+      "bar",
+    ],
+  },
+}
+`;
+
+exports[`dependency model > tracks dependency sets correctly 2`] = `
+Set {
+  BindingInstance {
+    "factory": [Function],
+    "joined": "foo.baz",
+    "split": [
+      "foo",
+      "baz",
+    ],
+  },
+  BindingInstance {
+    "factory": [Function],
+    "joined": "foo.bad",
+    "split": [
+      "foo",
+      "bad",
+    ],
+  },
+}
+`;
+
+exports[`dependency model > tracks dependency sets correctly 3`] = `
+Set {
+  BindingInstance {
+    "factory": [Function],
+    "joined": "foo.bar",
+    "split": [
+      "foo",
+      "bar",
+    ],
+  },
+  BindingInstance {
+    "factory": [Function],
+    "joined": "foo.baz",
+    "split": [
+      "foo",
+      "baz",
+    ],
+  },
+  BindingInstance {
+    "factory": [Function],
+    "joined": "foo.bad",
+    "split": [
+      "foo",
+      "bad",
+    ],
+  },
+}
+`;

package/src/data/__tests__/dependency-tracker.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from "vitest";
+import { BindingParser } from "../../binding";
+import { LocalModel, DependencyModel, DependencyMiddleware } from "..";
+
+const parser = new BindingParser({
+  get: () => undefined,
+  set: () => undefined,
+  evaluate: () => undefined,
+});
+const binding = parser.parse("foo.bar");
+
+describe("dependency model", () => {
+  it("tracks reads", () => {
+    const trackedModel = new DependencyModel(
+      new LocalModel({ foo: { bar: "baz" } }),
+    );
+
+    trackedModel.get(binding);
+    expect(trackedModel.readsBinding(binding)).toBe(true);
+    expect(trackedModel.readsBinding(parser.parse("foo.baz"))).toBe(false);
+    expect(trackedModel.getDependencies().size).toBe(1);
+  });
+
+  it("tracks writes", () => {
+    const trackedModel = new DependencyModel(
+      new LocalModel({ foo: { bar: "baz" } }),
+    );
+
+    trackedModel.set([[binding, "not baz"]]);
+    expect(trackedModel.writesBinding(binding)).toBe(true);
+    expect(trackedModel.writesBinding(parser.parse("foo.baz"))).toBe(false);
+    expect(trackedModel.getModified().size).toBe(1);
+  });
+
+  it(`uses the existing set instead of recreating a new one`, () => {
+    const trackedModel = new DependencyModel(
+      new LocalModel({ foo: { bar: "baz" } }),
+    );
+    const binding2 = parser.parse("foo.baz");
+
+    trackedModel.trackSubset("core");
+    trackedModel.get(binding);
+    trackedModel.trackSubset("core");
+    trackedModel.get(binding2);
+
+    expect(trackedModel.getDependencies("core").size).toBe(2);
+  });
+
+  it("tracks dependency sets correctly", () => {
+    const trackedModel = new DependencyModel(
+      new LocalModel({ foo: { bar: "baz" } }),
+    );
+    const binding2 = parser.parse("foo.baz");
+    const binding3 = parser.parse("foo.bad");
+
+    trackedModel.trackSubset("children");
+    trackedModel.get(binding);
+    trackedModel.trackSubset("core");
+    trackedModel.get(binding2);
+    trackedModel.trackDefault();
+    trackedModel.get(binding3);
+
+    expect(trackedModel.getDependencies("children")).toMatchSnapshot();
+    expect(trackedModel.getDependencies("core")).toMatchSnapshot();
+    expect(trackedModel.getDependencies()).toMatchSnapshot();
+
+    trackedModel.reset();
+    expect(trackedModel.getDependencies("children").size).toBe(0);
+    expect(trackedModel.getDependencies("core").size).toBe(0);
+    expect(trackedModel.getDependencies().size).toBe(0);
+  });
+
+  it("adds a tracked dependency to children set", () => {
+    const trackedModel = new DependencyModel(
+      new LocalModel({ foo: { bar: "baz" } }),
+    );
+
+    trackedModel.addChildReadDep(binding);
+    expect(trackedModel.getDependencies("children").size).toBe(1);
+    expect(trackedModel.getDependencies("core").size).toBe(0);
+    expect(trackedModel.getDependencies().size).toBe(1);
+  });
+});
+
+describe("dependency model middleware", () => {
+  it("tracks reads", () => {
+    const base = new LocalModel({ foo: { bar: "baz" } });
+    const trackedModel = new DependencyMiddleware();
+
+    trackedModel.get(binding, undefined, base);
+    expect(trackedModel.readsBinding(binding)).toBe(true);
+    expect(trackedModel.readsBinding(parser.parse("foo.baz"))).toBe(false);
+    expect(trackedModel.getDependencies().size).toBe(1);
+  });
+
+  it("tracks a subset of read dependencies", () => {
+    const base = new LocalModel({ foo: { bar: "baz" } });
+    const binding2 = parser.parse("foo.baz");
+    const trackedModel = new DependencyMiddleware();
+
+    trackedModel.trackSubset("children");
+    trackedModel.get(binding, undefined, base);
+    trackedModel.trackDefault();
+    trackedModel.get(binding2, undefined, base);
+
+    expect(trackedModel.getDependencies("children").size).toBe(1);
+    expect(trackedModel.getDependencies("core").size).toBe(1);
+    expect(trackedModel.getDependencies().size).toBe(2);
+
+    trackedModel.reset();
+    expect(trackedModel.getDependencies("children").size).toBe(0);
+    expect(trackedModel.getDependencies("core").size).toBe(0);
+    expect(trackedModel.getDependencies().size).toBe(0);
+  });
+
+  it("tracks writes", () => {
+    const base = new LocalModel({ foo: { bar: "baz" } });
+    const trackedModel = new DependencyMiddleware();
+    trackedModel.set([[binding, "not baz"]], undefined, base);
+    expect(trackedModel.writesBinding(binding)).toBe(true);
+    expect(trackedModel.writesBinding(parser.parse("foo.baz"))).toBe(false);
+    expect(trackedModel.getModified().size).toBe(1);
+    trackedModel.reset();
+    expect(trackedModel.getModified().size).toBe(0);
+  });
+
+  it("tracks a subset of write dependencies", () => {
+    const base = new LocalModel({ foo: { bar: "baz" } });
+    const binding2 = parser.parse("foo.baz");
+    const trackedModel = new DependencyMiddleware();
+
+    trackedModel.trackSubset("children");
+    trackedModel.set([[binding, "not baz"]], undefined, base);
+    trackedModel.trackDefault();
+    trackedModel.set([[binding2, "not bar"]], undefined, base);
+
+    expect(trackedModel.getModified("children").size).toBe(1);
+    expect(trackedModel.getModified("core").size).toBe(1);
+    expect(trackedModel.getModified().size).toBe(2);
+
+    trackedModel.reset();
+    expect(trackedModel.getModified("children").size).toBe(0);
+    expect(trackedModel.getModified("core").size).toBe(0);
+    expect(trackedModel.getModified().size).toBe(0);
+  });
+});

package/src/data/__tests__/local-model.test.ts

@@ -0,0 +1,46 @@
+import { it, expect } from "vitest";
+import { BindingParser } from "../../binding";
+import { LocalModel } from "..";
+
+const parser = new BindingParser({
+  get: () => undefined,
+  set: () => undefined,
+  evaluate: () => undefined,
+});
+const binding = parser.parse("foo.bar");
+it("sets data", () => {
+  const model = new LocalModel();
+  model.set([[binding, "baz"]]);
+  expect(model.get(binding)).toBe("baz");
+});
+
+it("overrides data", () => {
+  const model = new LocalModel({ foo: { bar: "baz" } });
+  expect(model.get(binding)).toBe("baz");
+  model.set([[binding, "not baz"]]);
+  expect(model.get(binding)).toBe("not baz");
+});
+
+it("gets data", () => {
+  const model = new LocalModel({ foo: { bar: "baz" } });
+  expect(model.get(binding)).toBe("baz");
+});
+
+it("resets data", () => {
+  const model = new LocalModel({ foo: { bar: "baz" } });
+  expect(model.get(binding)).toBe("baz");
+  model.reset();
+  expect(model.get(binding)).toBe(undefined);
+});
+
+it("resets data starting with new model", () => {
+  const model = new LocalModel({ foo: { bar: "baz" } });
+  expect(model.get(binding)).toBe("baz");
+  model.reset({ foo: { bar: "not baz" } });
+  expect(model.get(binding)).toBe("not baz");
+});
+
+it("retuns the whole model when no binding is passed", () => {
+  const model = new LocalModel({ foo: { bar: "baz" } });
+  expect(model.get()).toStrictEqual({ foo: { bar: "baz" } });
+});

package/src/data/__tests__/model.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, vitest } from "vitest";
+import { BindingInstance, BindingParser } from "../../binding";
+import type { DataModelMiddleware } from "..";
+import { LocalModel, PipelinedDataModel } from "..";
+import { withParser } from "../model";
+import type { BatchSetTransaction } from "../model";
+
+const { parse } = new BindingParser({
+  get: () => undefined,
+  set: () => undefined,
+  evaluate: () => undefined,
+});
+
+describe("model", () => {
+  let localModel: LocalModel;
+  let model: PipelinedDataModel;
+
+  beforeEach(() => {
+    localModel = new LocalModel();
+
+    const middleware: DataModelMiddleware = {
+      get(binding, options, next) {
+        return next?.get(binding, options);
+      },
+      set(transaction, options, next) {
+        const newTransaction: BatchSetTransaction = [];
+        transaction.forEach(([binding, val]) => {
+          if (val !== "bad") {
+            newTransaction.push([binding, val]);
+          }
+        });
+
+        return next?.set(newTransaction, options) ?? [];
+      },
+    };
+
+    model = new PipelinedDataModel();
+    model.addMiddleware(localModel);
+    model.addMiddleware(middleware);
+  });
+
+  it("works with basic middleware", () => {
+    model.set([
+      [parse("foo.bar"), "bad"],
+      [parse("foo.baz"), "good"],
+    ]);
+
+    expect(localModel.get(parse("foo.bar"))).toBe(undefined);
+    expect(localModel.get(parse("foo.baz"))).toBe("good");
+  });
+
+  it("works with withParser", () => {
+    const mockParse = vitest.fn(() => new BindingInstance(["some", "binding"]));
+
+    const modelWithParser = withParser(model, mockParse);
+
+    modelWithParser.get("some.binding");
+
+    expect(mockParse).toHaveBeenCalledWith(
+      "some.binding",
+      expect.objectContaining({ readOnly: true }),
+    );
+
+    modelWithParser.set([["some.binding", "test"]]);
+
+    expect(mockParse).toHaveBeenCalledWith(
+      "some.binding",
+      expect.objectContaining({ readOnly: false }),
+    );
+
+    modelWithParser.delete(["some.binding"]);
+
+    expect(mockParse).toHaveBeenCalledWith(
+      "some.binding",
+      expect.objectContaining({ readOnly: false }),
+    );
+  });
+});