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

package/src/data/dependency-tracker.ts

@@ -0,0 +1,187 @@
+import type { BindingInstance } from '../binding';
+import type {
+  BatchSetTransaction,
+  DataModelImpl,
+  DataModelMiddleware,
+  DataModelOptions,
+  Updates,
+} from './model';
+
+export type DependencySets = 'core' | 'children';
+
+/** A class to track usage of read/writes to/from a data model */
+export class DependencyTracker {
+  protected readDeps: Set<BindingInstance>;
+  protected writeDeps: Set<BindingInstance>;
+  protected namedSet: DependencySets;
+
+  private namedDependencySets: Partial<
+    Record<
+      DependencySets,
+      {
+        /** readDeps */
+        readDeps: Set<BindingInstance>;
+        /** writeDeps */
+        writeDeps: Set<BindingInstance>;
+      }
+    >
+  >;
+
+  constructor() {
+    this.readDeps = new Set();
+    this.writeDeps = new Set();
+    this.namedDependencySets = {};
+    this.namedSet = 'core';
+
+    this.createSubset('core');
+    this.createSubset('children');
+  }
+
+  protected createSubset(name: DependencySets, force = false): void {
+    if (force || !this.namedDependencySets[name]) {
+      this.namedDependencySets[name] = {
+        readDeps: new Set(),
+        writeDeps: new Set(),
+      };
+    }
+  }
+
+  /** Grab all of the bindings that this depended on */
+  public getDependencies(name?: DependencySets): Set<BindingInstance> {
+    if (name !== undefined) {
+      return this.namedDependencySets?.[name]?.readDeps ?? new Set();
+    }
+
+    return this.readDeps;
+  }
+
+  public trackSubset(name: DependencySets) {
+    this.createSubset(name);
+    this.namedSet = name;
+  }
+
+  public trackDefault() {
+    this.namedSet = 'core';
+  }
+
+  /** Grab all of the bindings this wrote to */
+  public getModified(name?: DependencySets): Set<BindingInstance> {
+    if (name !== undefined) {
+      return this.namedDependencySets?.[name]?.writeDeps ?? new Set();
+    }
+
+    return this.writeDeps;
+  }
+
+  /**
+   * Check to see if the dataModel has read the value at the given binding
+   *
+   * @param binding - The binding you want to check for
+   */
+  public readsBinding(binding: BindingInstance): boolean {
+    return this.readDeps.has(binding);
+  }
+
+  /**
+   * Check to see if the dataModel has written to the binding
+   */
+  public writesBinding(binding: BindingInstance): boolean {
+    return this.writeDeps.has(binding);
+  }
+
+  /** Reset all tracking of dependencies */
+  public reset() {
+    this.readDeps = new Set();
+    this.writeDeps = new Set();
+    this.namedDependencySets = {};
+    this.namedSet = 'core';
+
+    this.createSubset('core', true);
+    this.createSubset('children', true);
+  }
+
+  protected addReadDep(
+    binding: BindingInstance,
+    namedSet = this.namedSet
+  ): void {
+    if (namedSet) {
+      this.namedDependencySets?.[namedSet]?.readDeps.add(binding);
+    }
+
+    this.readDeps.add(binding);
+  }
+
+  protected addWriteDep(
+    binding: BindingInstance,
+    namedSet = this.namedSet
+  ): void {
+    if (namedSet) {
+      this.namedDependencySets?.[namedSet]?.writeDeps.add(binding);
+    }
+
+    this.writeDeps.add(binding);
+  }
+
+  public addChildReadDep(binding: BindingInstance): void {
+    this.addReadDep(binding, 'children');
+  }
+}
+
+/** Middleware that tracks dependencies of read/written data */
+export class DependencyMiddleware
+  extends DependencyTracker
+  implements DataModelMiddleware
+{
+  constructor() {
+    super();
+    this.get = this.get.bind(this);
+    this.set = this.set.bind(this);
+  }
+
+  public set(
+    transaction: BatchSetTransaction,
+    options?: DataModelOptions,
+    next?: DataModelImpl | undefined
+  ): Updates {
+    transaction.forEach(([binding]) => this.addWriteDep(binding));
+
+    return next?.set(transaction, options) ?? [];
+  }
+
+  public get(
+    binding: BindingInstance,
+    options?: DataModelOptions,
+    next?: DataModelImpl | undefined
+  ) {
+    this.addReadDep(binding);
+
+    return next?.get(binding, options);
+  }
+}
+
+/** A data-model that tracks dependencies of read/written data */
+export class DependencyModel<Options = DataModelOptions>
+  extends DependencyTracker
+  implements DataModelImpl<Options>
+{
+  private readonly rootModel: DataModelImpl<Options>;
+
+  constructor(rootModel: DataModelImpl<Options>) {
+    super();
+    this.rootModel = rootModel;
+    this.set = this.set.bind(this);
+    this.get = this.get.bind(this);
+  }
+
+  public set(transaction: BatchSetTransaction, options?: Options): Updates {
+    transaction.forEach(([binding]) => this.addWriteDep(binding));
+
+    return this.rootModel.set(transaction, options);
+  }
+
+  public get(binding: BindingInstance, options?: Options) {
+    this.addReadDep(binding);
+
+    return this.rootModel.get(binding, options);
+  }
+}

package/src/data/index.ts

@@ -0,0 +1,4 @@
+export * from './dependency-tracker';
+export * from './model';
+export * from './noop-model';
+export * from './local-model';

package/src/data/local-model.ts

@@ -0,0 +1,41 @@
+import get from 'dlv';
+import { setIn } from 'timm';
+import type { BindingInstance } from '../binding';
+import type { BatchSetTransaction, DataModelImpl, Updates } from './model';
+
+/**
+ * A data model that stores data in an in-memory JS object
+ */
+export class LocalModel implements DataModelImpl {
+  public model: {
+    [key: string]: any;
+  };
+
+  constructor(model = {}) {
+    this.model = model;
+    this.get = this.get.bind(this);
+    this.set = this.set.bind(this);
+  }
+
+  public reset(model = {}) {
+    this.model = model;
+  }
+
+  public get(binding?: BindingInstance) {
+    if (!binding || !binding.asString()) {
+      return this.model;
+    }
+
+    return get(this.model, binding.asArray() as string[]);
+  }
+
+  public set(transaction: BatchSetTransaction) {
+    const effectiveOperations: Updates = [];
+    transaction.forEach(([binding, value]) => {
+      const oldValue = this.get(binding);
+      this.model = setIn(this.model, binding.asArray(), value) as any;
+      effectiveOperations.push({ binding, oldValue, newValue: value });
+    });
+    return effectiveOperations;
+  }
+}

package/src/data/model.ts

@@ -0,0 +1,216 @@
+import { SyncHook } from 'tapable-ts';
+import type { BindingLike, BindingFactory } from '../binding';
+import { BindingInstance, isBinding } from '../binding';
+import { NOOP_MODEL } from './noop-model';
+
+export const ROOT_BINDING = new BindingInstance([]);
+export type BatchSetTransaction = [BindingInstance, any][];
+
+export type Updates = Array<{
+  /** The updated binding */
+  binding: BindingInstance;
+
+  /** The old value */
+  oldValue: any;
+
+  /** The new value */
+  newValue: any;
+
+  /** Force the Update to be included even if no data changed */
+  force?: boolean;
+}>;
+
+/** Options to use when getting or setting data */
+export interface DataModelOptions {
+  /**
+   * The data (either to set or get) should represent a formatted value
+   * For setting data, the data will be de-formatted before continuing in the pipeline
+   * For getting data, the data will be formatted before returning
+   */
+  formatted?: boolean;
+
+  /**
+   * By default, fetching data will ignore any invalid data.
+   * You can choose to grab the queued invalid data if you'd like
+   * This is usually the case for user-inputs
+   */
+  includeInvalid?: boolean;
+
+  /**
+   * A flag to set to ignore any default value in the schema, and just use the raw value
+   */
+  ignoreDefaultValue?: boolean;
+
+  /** Other context associated with this request */
+  context?: {
+    /** The data model to use when getting other data from the context of this request */
+    model: DataModelWithParser;
+  };
+}
+
+export interface DataModelWithParser<Options = DataModelOptions> {
+  get(binding: BindingLike, options?: Options): any;
+  set(transaction: [BindingLike, any][], options?: Options): Updates;
+}
+
+export interface DataModelImpl<Options = DataModelOptions> {
+  get(binding: BindingInstance, options?: Options): any;
+  set(transaction: BatchSetTransaction, options?: Options): Updates;
+}
+
+export interface DataModelMiddleware {
+  /** The name of the middleware */
+  name?: string;
+
+  set(
+    transaction: BatchSetTransaction,
+    options?: DataModelOptions,
+    next?: DataModelImpl
+  ): Updates;
+  get(
+    binding: BindingInstance,
+    options?: DataModelOptions,
+    next?: DataModelImpl
+  ): any;
+  reset?(): void;
+}
+
+/** Wrap the inputs of the DataModel with calls to parse raw binding inputs */
+export function withParser<Options = unknown>(
+  model: DataModelImpl<Options>,
+  parseBinding: BindingFactory
+): DataModelWithParser<Options> {
+  /** Parse something into a binding if it requires it */
+  function maybeParse(binding: BindingLike): BindingInstance {
+    const parsed = isBinding(binding)
+      ? binding
+      : parseBinding(binding, {
+          get: model.get,
+          set: model.set,
+        });
+
+    if (!parsed) {
+      throw new Error('Unable to parse binding');
+    }
+
+    return parsed;
+  }
+
+  return {
+    get(binding, options?: Options) {
+      return model.get(maybeParse(binding), options);
+    },
+    set(transaction, options?: Options) {
+      return model.set(
+        transaction.map(([key, val]) => [maybeParse(key), val]),
+        options
+      );
+    },
+  };
+}
+
+/** Wrap a middleware instance in a DataModel compliant API */
+export function toModel(
+  middleware: DataModelMiddleware,
+  defaultOptions?: DataModelOptions,
+  next?: DataModelImpl
+): DataModelImpl {
+  if (!next) {
+    return middleware as DataModelImpl;
+  }
+
+  return {
+    get: (binding: BindingInstance, options?: DataModelOptions) =>
+      middleware.get(binding, options ?? defaultOptions, next),
+    set: (transaction: BatchSetTransaction, options?: DataModelOptions) =>
+      middleware.set(transaction, options ?? defaultOptions, next),
+  };
+}
+
+export type DataPipeline = Array<DataModelMiddleware | DataModelImpl>;
+
+/**
+ * Given a set of steps in a pipeline, create the effective data-model
+ */
+export function constructModelForPipeline(
+  pipeline: DataPipeline
+): DataModelImpl {
+  if (pipeline.length === 0) {
+    return NOOP_MODEL;
+  }
+
+  if (pipeline.length === 1) {
+    return pipeline[0];
+  }
+
+  /** Default and propagate the options into the nested calls */
+  function createModelWithOptions(options?: DataModelOptions) {
+    const model: DataModelImpl =
+      pipeline.reduce<DataModelImpl | undefined>(
+        (nextModel, middleware) => toModel(middleware, options, nextModel),
+        undefined
+      ) ?? NOOP_MODEL;
+
+    return model;
+  }
+
+  return {
+    get: (binding: BindingInstance, options?: DataModelOptions) => {
+      return createModelWithOptions(options)?.get(binding, options);
+    },
+    set: (transaction, options) => {
+      return createModelWithOptions(options)?.set(transaction, options);
+    },
+  };
+}
+
+/** A DataModel that manages middleware data handlers  */
+export class PipelinedDataModel implements DataModelImpl {
+  private pipeline: DataPipeline;
+  private effectiveDataModel: DataModelImpl;
+
+  public readonly hooks = {
+    onSet: new SyncHook<[BatchSetTransaction]>(),
+  };
+
+  constructor(pipeline: DataPipeline = []) {
+    this.pipeline = pipeline;
+    this.effectiveDataModel = constructModelForPipeline(this.pipeline);
+  }
+
+  public setMiddleware(handlers: DataPipeline) {
+    this.pipeline = handlers;
+    this.effectiveDataModel = constructModelForPipeline(handlers);
+  }
+
+  public addMiddleware(handler: DataModelMiddleware) {
+    this.pipeline = [...this.pipeline, handler];
+    this.effectiveDataModel = constructModelForPipeline(this.pipeline);
+  }
+
+  public reset(model = {}) {
+    this.pipeline.forEach((middleware) => {
+      if ('reset' in middleware) {
+        middleware.reset?.();
+      }
+    });
+
+    this.set([[ROOT_BINDING, model]]);
+  }
+
+  public set(
+    transaction: BatchSetTransaction,
+    options?: DataModelOptions
+  ): Updates {
+    const appliedTransaction = this.effectiveDataModel.set(
+      transaction,
+      options
+    );
+    this.hooks.onSet.call(transaction);
+    return appliedTransaction;
+  }
+
+  public get(binding: BindingInstance, options?: DataModelOptions): any {
+    return this.effectiveDataModel.get(binding, options);
+  }
+}

package/src/data/noop-model.ts

@@ -0,0 +1,18 @@
+import type { DataModelImpl } from './model';
+
+/**
+ * A model that does nothing
+ * Helpful for testing and other default DataModel applications
+ */
+export class NOOPDataModel implements DataModelImpl {
+  get() {
+    return undefined;
+  }
+
+  set() {
+    return [];
+  }
+}
+
+/** You only really need 1 instance of the NOOP model */
+export const NOOP_MODEL = new NOOPDataModel();

package/src/expressions/evaluator-functions.ts

@@ -0,0 +1,29 @@
+import type { Binding } from '@player-ui/types';
+
+import type { BindingLike } from '../binding';
+import type { ExpressionHandler, ExpressionContext } from './types';
+
+/** Sets a value to the data-model */
+export const setDataVal: ExpressionHandler<[Binding, any], any> = (
+  _context: ExpressionContext,
+  binding,
+  value
+) => {
+  _context.model.set([[binding as BindingLike, value]]);
+};
+
+/** Fetches a valid from the data-model */
+export const getDataVal: ExpressionHandler<[Binding], unknown> = (
+  _context: ExpressionContext,
+  binding
+) => {
+  return _context.model.get(binding as BindingLike);
+};
+
+/** Deletes a value from the model */
+export const deleteDataVal: ExpressionHandler<[Binding], void> = (
+  _context: ExpressionContext,
+  binding
+) => {
+  return _context.model.set([[binding as BindingLike, undefined]]);
+};