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

package/src/expressions/types.ts

@@ -0,0 +1,200 @@
+import type { DataModelWithParser } from '../data';
+import type { Logger } from '../logger';
+
+export type ExpressionLiteralType =
+  | string
+  | number
+  | boolean
+  | undefined
+  | null;
+export type ExpressionType =
+  | object
+  | ExpressionLiteralType
+  | Array<ExpressionLiteralType>
+  | ExpressionNode;
+
+export interface OperatorProcessingOptions {
+  /**
+   * When set to a falsy value, the arguments passed to the handler will be raw AST Nodes
+   * This enables lazy evaluation of arguments
+   */
+  resolveParams: boolean;
+}
+
+export type BinaryOperatorBasic = (left: any, right: any) => unknown;
+export type BinaryOperatorAdvanced = OperatorProcessingOptions &
+  ((ctx: ExpressionContext, left: any, right: any) => unknown);
+
+export type BinaryOperator = BinaryOperatorAdvanced | BinaryOperatorBasic;
+
+export type UnaryOperator =
+  | ((arg: any) => unknown)
+  | (((ctx: ExpressionContext, arg: any) => unknown) &
+      OperatorProcessingOptions);
+
+export interface ExpressionContext {
+  /** A means of executing an expression */
+  evaluate: (expr: ExpressionType) => unknown;
+
+  /** The data model that expression handlers can use when fetching data */
+  model: DataModelWithParser;
+
+  /** A logger to use */
+  logger?: Logger;
+}
+
+export type ExpressionHandler<
+  T extends readonly unknown[] = unknown[],
+  R = void
+> = ((context: ExpressionContext, ...args: T) => R) &
+  Partial<OperatorProcessingOptions>;
+
+export const ExpNodeOpaqueIdentifier = Symbol('Expression Node ID');
+
+/** Checks if the input is an already processed Expression node */
+export function isExpressionNode(x: any): x is ExpressionNode {
+  return typeof x === 'object' && x.__id === ExpNodeOpaqueIdentifier;
+}
+
+export interface BaseNode<T> {
+  /** The thing to discriminate the AST type on */
+  type: T;
+
+  /** How to tell this apart from other objects */
+  __id: typeof ExpNodeOpaqueIdentifier;
+}
+
+/** A helper interface for nodes that container left and right children */
+export interface DirectionalNode {
+  /** The left node. Often for the left hand side of an expression */
+  left: ExpressionNode;
+
+  /** The right child. Often for the right hand side of an expression */
+  right: ExpressionNode;
+}
+
+export interface LiteralNode extends BaseNode<'Literal'> {
+  /** A node that holds a literal value */
+  value: string | number;
+
+  /** The unprocessed value */
+  raw?: any;
+}
+
+export interface BinaryNode
+  extends BaseNode<'BinaryExpression'>,
+    DirectionalNode {
+  /** The operation to perform on the nodes */
+  operator: string;
+}
+
+export interface LogicalNode extends BaseNode<'LogicalExpression'> {
+  /** The left hand side of the equation */
+  left: any;
+
+  /** The right hand side of the equation */
+  right: any;
+
+  /** The logical operation to perform on the nodes */
+  operator: string;
+}
+
+export interface UnaryNode extends BaseNode<'UnaryExpression'> {
+  /** The operation to perform on the node */
+  operator: string;
+
+  /** The single argument that the operation should be performed on */
+  argument: any;
+}
+
+export type ThisNode = BaseNode<'ThisExpression'>;
+
+export interface ModelRefNode extends BaseNode<'ModelRef'> {
+  /** The binding that the model reference points to */
+  ref: string;
+}
+
+export interface ObjectNode extends BaseNode<'Object'> {
+  /**  */
+  attributes: Array<{
+    /** The property name of the object */
+    key: any;
+
+    /** the associated value */
+    value: any;
+  }>;
+}
+
+export interface MemberExpressionNode extends BaseNode<'MemberExpression'> {
+  /** The object to be introspected */
+  object: ExpressionNode;
+
+  /** If the property uses . or open-bracket */
+  computed: boolean;
+
+  /** The property to access on the object */
+  property: ExpressionNode;
+}
+
+export interface ConditionalExpressionNode
+  extends BaseNode<'ConditionalExpression'> {
+  /** The test for the ternary */
+  test: ExpressionNode;
+
+  /** The truthy case for the ternary */
+  consequent: ExpressionNode;
+
+  /** The falsy case for the ternary */
+  alternate: ExpressionNode;
+}
+
+export interface CompoundNode extends BaseNode<'Compound'> {
+  /** The contents of the compound expression */
+  body: ExpressionNode[];
+}
+
+export interface CallExpressionNode extends BaseNode<'CallExpression'> {
+  /** The arguments to the function */
+  args: any[];
+
+  /** The function name */
+  callTarget: IdentifierNode;
+}
+
+export interface ArrayExpressionNode extends BaseNode<'ArrayExpression'> {
+  /** The items in an array */
+  elements: any[];
+}
+
+export interface IdentifierNode extends BaseNode<'Identifier'> {
+  /** The variable name */
+  name: string;
+}
+
+export type AssignmentNode = BaseNode<'Assignment'> & DirectionalNode;
+
+export interface ModificationNode
+  extends BaseNode<'Modification'>,
+    DirectionalNode {
+  /** The operator for the modification */
+  operator: string;
+}
+
+export type ExpressionNode =
+  | LiteralNode
+  | BinaryNode
+  | LogicalNode
+  | UnaryNode
+  | ThisNode
+  | ModelRefNode
+  | MemberExpressionNode
+  | ConditionalExpressionNode
+  | CompoundNode
+  | CallExpressionNode
+  | ArrayExpressionNode
+  | IdentifierNode
+  | AssignmentNode
+  | ModificationNode
+  | ObjectNode;
+
+export type ExpressionNodeType = ExpressionNode['type'];

package/src/expressions/utils.ts

@@ -0,0 +1,8 @@
+import type { ExpressionHandler } from './types';
+
+/** Generates a function by removing the first context argument */
+export function withoutContext<T extends unknown[], Return>(
+  fn: (...args: T) => Return
+): ExpressionHandler<T, Return> {
+  return (_context, ...args) => fn(...args);
+}

package/src/index.ts

@@ -1,18 +1,15 @@
 // Add the types export first so it's naming takes precedence
 export * from '@player-ui/types';
-export * from '@player-ui/binding';
-export * from '@player-ui/data';
-export * from '@player-ui/expressions';
-export * from '@player-ui/flow';
-export * from '@player-ui/logger';
-export * from '@player-ui/schema';
-export * from '@player-ui/string-resolver';
-export * from '@player-ui/validator';
-export * from '@player-ui/view';
+export * from './binding';
+export * from './data';
+export * from './expressions';
+export * from './logger';
+export * from './schema';
+export * from './string-resolver';
+export * from './validator';
+export * from './view';
 
 export * from './player';
-export * from './validation';
-export * from './view';
-export * from './data';
+export * from './controllers';
 export * from './types';
 export * from './plugins/flow-exp-plugin';

package/src/logger/consoleLogger.ts

@@ -0,0 +1,49 @@
+import type { Logger, Severity } from './types';
+import { severities } from './types';
+
+export type ConsoleHandler = Pick<typeof console, 'log' | 'warn' | 'error'>;
+
+/** A Logger implementation that uses console */
+export default class ConsoleLogger implements Logger {
+  private severity: Severity;
+  private _console: ConsoleHandler;
+
+  constructor(severity: Severity = 'warn', _console: ConsoleHandler = console) {
+    this.severity = severity;
+    this._console = _console;
+  }
+
+  public setSeverity(severity: Severity) {
+    this.severity = severity;
+  }
+
+  private getConsoleFn(severity: Severity) {
+    switch (severities.indexOf(severity)) {
+      case 0:
+      case 1:
+      case 2:
+        return this._console.log;
+      case 3:
+        return this._console.warn;
+      default:
+        return this._console.error;
+    }
+  }
+
+  private createHandler(severity: Severity): (...args: any[]) => void {
+    return (...args: any[]) => {
+      const sevIndex = severities.indexOf(severity);
+      const sevConf = severities.indexOf(this.severity);
+
+      if (sevIndex >= sevConf) {
+        this.getConsoleFn(severity)(`player - ${severity} -`, ...args);
+      }
+    };
+  }
+
+  public readonly trace = this.createHandler('trace');
+  public readonly debug = this.createHandler('debug');
+  public readonly info = this.createHandler('info');
+  public readonly warn = this.createHandler('warn');
+  public readonly error = this.createHandler('error');
+}

package/src/logger/index.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export { default as ConsoleLogger } from './consoleLogger';
+export { default as NoopLogger } from './noopLogger';
+export { default as TapableLogger } from './tapableLogger';
+export { default as ProxyLogger } from './proxyLogger';

package/src/logger/noopLogger.ts

@@ -0,0 +1,13 @@
+import type { Logger } from './types';
+
+/** An empty function so the logger ignore everything */
+const noop = () => {};
+
+/** A logger implementation that goes nowhere */
+export default class NoopLogger implements Logger {
+  public readonly trace = noop;
+  public readonly debug = noop;
+  public readonly info = noop;
+  public readonly warn = noop;
+  public readonly error = noop;
+}

package/src/logger/proxyLogger.ts

@@ -0,0 +1,25 @@
+import type { Logger, Severity, LoggerProvider } from './types';
+
+/**
+ * The ProxyLogger allows a user to log to another Logger instance that may not exist yet
+ */
+export default class ProxyLogger implements Logger {
+  private proxiedLoggerProvider: LoggerProvider;
+
+  constructor(loggerProvider: LoggerProvider) {
+    this.proxiedLoggerProvider = loggerProvider;
+  }
+
+  private createHandler(severity: Severity): (...args: any[]) => void {
+    return (...args: any[]) => {
+      const logger = this.proxiedLoggerProvider();
+      logger?.[severity](...args);
+    };
+  }
+
+  public readonly trace = this.createHandler('trace');
+  public readonly debug = this.createHandler('debug');
+  public readonly info = this.createHandler('info');
+  public readonly warn = this.createHandler('warn');
+  public readonly error = this.createHandler('error');
+}

package/src/logger/tapableLogger.ts

@@ -0,0 +1,38 @@
+import { SyncHook } from 'tapable-ts';
+import type { Logger, Severity } from './types';
+
+/** A logger that has a tapable subscriptions to callbacks */
+export default class TapableLogger implements Logger {
+  public readonly hooks = {
+    trace: new SyncHook<[Array<any>]>(),
+    debug: new SyncHook<[Array<any>]>(),
+    info: new SyncHook<[Array<any>]>(),
+    warn: new SyncHook<[Array<any>]>(),
+    error: new SyncHook<[Array<any>]>(),
+    log: new SyncHook<[Severity, Array<any>]>(),
+  };
+
+  private logHandlers: Set<Logger> = new Set();
+
+  private createHandler(severity: Severity): (...args: any[]) => void {
+    return (...args: any[]) => {
+      this.hooks[severity].call(args);
+      this.hooks.log.call(severity, args);
+      this.logHandlers.forEach((logger) => logger[severity](...args));
+    };
+  }
+
+  public addHandler(logHandler: Logger) {
+    this.logHandlers.add(logHandler);
+  }
+
+  public removeHandler(logHandler: Logger) {
+    this.logHandlers.delete(logHandler);
+  }
+
+  public readonly trace = this.createHandler('trace');
+  public readonly debug = this.createHandler('debug');
+  public readonly info = this.createHandler('info');
+  public readonly warn = this.createHandler('warn');
+  public readonly error = this.createHandler('error');
+}

package/src/logger/types.ts

@@ -0,0 +1,6 @@
+export type LogFn = (...args: Array<any>) => void;
+
+export const severities = ['trace', 'debug', 'info', 'warn', 'error'] as const;
+export type Severity = typeof severities[number];
+export type Logger = Record<Severity, LogFn>;
+export type LoggerProvider = () => Logger | undefined;

package/src/player.ts

@@ -1,22 +1,25 @@
-import { SyncHook, SyncWaterfallHook } from 'tapable-ts';
-import type { FlowInstance } from '@player-ui/flow';
-import { FlowController } from '@player-ui/flow';
-import type { Logger } from '@player-ui/logger';
-import { TapableLogger } from '@player-ui/logger';
-import type { ExpressionHandler } from '@player-ui/expressions';
-import { ExpressionEvaluator } from '@player-ui/expressions';
-import { SchemaController } from '@player-ui/schema';
-import { BindingParser } from '@player-ui/binding';
-import type { ViewInstance } from '@player-ui/view';
 import { setIn } from 'timm';
 import deferred from 'p-defer';
-import type { Flow as FlowType, FlowResult } from '@player-ui/types';
-import { resolveDataRefs } from '@player-ui/string-resolver';
-import { ConstantsController } from '@player-ui/constants';
 import queueMicrotask from 'queue-microtask';
-import { ViewController } from './view';
-import { DataController } from './data';
-import { ValidationController } from './validation';
+import type { Flow as FlowType, FlowResult } from '@player-ui/types';
+
+import { SyncHook, SyncWaterfallHook } from 'tapable-ts';
+import type { Logger } from './logger';
+import { TapableLogger } from './logger';
+import type { ExpressionHandler } from './expressions';
+import { ExpressionEvaluator } from './expressions';
+import { SchemaController } from './schema';
+import { BindingParser } from './binding';
+import type { ViewInstance } from './view';
+import { resolveDataRefs } from './string-resolver';
+import type { FlowInstance } from './controllers';
+import {
+  ConstantsController,
+  ViewController,
+  DataController,
+  ValidationController,
+  FlowController,
+} from './controllers';
 import { FlowExpPlugin } from './plugins/flow-exp-plugin';
 import type {
   PlayerFlowState,
@@ -27,8 +30,8 @@ import type {
 import { NOT_STARTED_STATE } from './types';
 
 // Variables injected at build time
-const PLAYER_VERSION = '0.3.0-next.2';
-const COMMIT = '3b8d937ea6cb5b198dc8e1b834644666884c5d18';
+const PLAYER_VERSION = '0.3.0-next.4';
+const COMMIT = '774a3cf3b0765796901d03a311a06ee68e690a74';
 
 export interface PlayerPlugin {
   /**

package/src/plugins/flow-exp-plugin.ts

@@ -3,10 +3,9 @@ import type {
   ExpressionObject,
   NavigationFlowState,
 } from '@player-ui/types';
-import type { ExpressionEvaluator } from '@player-ui/expressions';
-import type { FlowInstance } from '@player-ui/flow';
+import type { ExpressionEvaluator } from '../expressions';
+import type { FlowInstance } from '../controllers';
 import type { Player, PlayerPlugin } from '../player';
-import type { InProgressState } from '../types';
 
 /**
  * A plugin that taps into the flow controller to evaluate available expressions

package/src/schema/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './schema';

package/src/schema/schema.ts

@@ -0,0 +1,220 @@
+import { SyncWaterfallHook } from 'tapable-ts';
+import type { Schema as SchemaType, Formatting } from '@player-ui/types';
+
+import type { BindingInstance } from '../binding';
+import type { ValidationProvider, ValidationObject } from '../validator';
+import type { FormatDefinition, FormatOptions, FormatType } from './types';
+
+/** A function that returns itself */
+const identify = (val: any) => val;
+
+/** Expand the authored schema into a set of paths -> DataTypes */
+export function parse(
+  schema: SchemaType.Schema
+): Map<string, SchemaType.DataType> {
+  const expandedPaths = new Map<string, SchemaType.DataType>();
+
+  if (!schema.ROOT) {
+    return expandedPaths;
+  }
+
+  const parseQueue: Array<{
+    /** The node to process */
+    node: SchemaType.Node;
+
+    /** The path in the data-model this node represents */
+    path: Array<string>;
+
+    /** A set of visited DataTypes to prevent loops */
+    visited: Set<string>;
+  }> = [{ node: schema.ROOT, path: [], visited: new Set() }];
+
+  while (parseQueue.length > 0) {
+    const next = parseQueue.shift();
+
+    if (!next) {
+      break;
+    }
+
+    const { node, path, visited } = next;
+
+    Object.entries(node).forEach(([prop, type]) => {
+      const nestedPath = [...path, prop];
+
+      const nestedPathStr = nestedPath.join('.');
+
+      if (expandedPaths.has(nestedPathStr)) {
+        // We've gone in a loop. Panic
+        throw new Error(
+          "Path has already been processed. There's either a loop somewhere or a bug"
+        );
+      }
+
+      if (visited.has(type.type)) {
+        throw new Error(
+          `Path already contained type: ${type.type}. This likely indicates a loop in the schema`
+        );
+      }
+
+      expandedPaths.set(nestedPathStr, type);
+
+      if (type.isArray) {
+        nestedPath.push('[]');
+      }
+
+      if (type.type && schema[type.type]) {
+        parseQueue.push({
+          path: nestedPath,
+          node: schema[type.type],
+          visited: new Set([...visited, type.type]),
+        });
+      }
+    });
+  }
+
+  return expandedPaths;
+}
+
+/**
+ * The Schema is the central hub for all data invariants, and metaData associated with the data-model itself
+ * Outside of the types defined in the JSON payload, it doesn't manage or keep any state.
+ * It simply servers as an orchestrator for other modules to interface w/ the schema.
+ */
+export class SchemaController implements ValidationProvider {
+  private formatters: Map<string, FormatType<any, any, FormatOptions>> =
+    new Map();
+
+  private types: Map<string, SchemaType.DataType<any>> = new Map();
+  public readonly schema: Map<string, SchemaType.DataType> = new Map();
+
+  private bindingSchemaNormalizedCache: Map<BindingInstance, string> =
+    new Map();
+
+  public readonly hooks = {
+    resolveTypeForBinding: new SyncWaterfallHook<
+      [SchemaType.DataType | undefined, BindingInstance]
+    >(),
+  };
+
+  constructor(schema?: SchemaType.Schema) {
+    this.schema = schema ? parse(schema) : new Map();
+  }
+
+  public addFormatters(fns: Array<FormatType<any, any, FormatOptions>>) {
+    fns.forEach((def) => {
+      this.formatters.set(def.name, def);
+    });
+  }
+
+  public addDataTypes(types: Array<SchemaType.DataType<any>>) {
+    types.forEach((t) => {
+      this.types.set(t.type, t);
+    });
+  }
+
+  getValidationsForBinding(
+    binding: BindingInstance
+  ): Array<ValidationObject> | undefined {
+    const typeDef = this.getApparentType(binding);
+
+    if (!typeDef?.validation?.length) {
+      return undefined;
+    }
+
+    // Set the defaults for schema-level validations
+    return typeDef.validation.map((vRef) => ({
+      severity: 'error',
+      trigger: 'change',
+      ...vRef,
+    }));
+  }
+
+  private normalizeBinding(binding: BindingInstance): string {
+    const cached = this.bindingSchemaNormalizedCache.get(binding);
+    if (cached) {
+      return cached;
+    }
+
+    const normalized = binding
+      .asArray()
+      .map((p) => (typeof p === 'number' ? '[]' : p))
+      .join('.');
+
+    this.bindingSchemaNormalizedCache.set(binding, normalized);
+
+    return normalized;
+  }
+
+  public getType(binding: BindingInstance): SchemaType.DataType | undefined {
+    return this.hooks.resolveTypeForBinding.call(
+      this.schema.get(this.normalizeBinding(binding)),
+      binding
+    );
+  }
+
+  public getApparentType(
+    binding: BindingInstance
+  ): SchemaType.DataType | undefined {
+    const schemaType = this.getType(binding);
+
+    if (schemaType === undefined) {
+      return undefined;
+    }
+
+    const baseType = this.getTypeDefinition(schemaType?.type);
+
+    if (baseType === undefined) {
+      return schemaType;
+    }
+
+    return {
+      ...baseType,
+      ...schemaType,
+      validation: [
+        ...(schemaType.validation ?? []),
+        ...(baseType.validation ?? []),
+      ],
+    };
+  }
+
+  public getTypeDefinition(dataType: string) {
+    return this.types.get(dataType);
+  }
+
+  public getFormatterForType(
+    formatReference: Formatting.Reference
+  ): FormatDefinition<unknown, unknown> | undefined {
+    const { type: formatType, ...options } = formatReference;
+
+    const formatter = this.formatters.get(formatType);
+
+    if (!formatter) {
+      return;
+    }
+
+    return {
+      format: formatter.format
+        ? (val) => formatter.format?.(val, options)
+        : identify,
+      deformat: formatter.deformat
+        ? (val) => formatter.deformat?.(val, options)
+        : identify,
+    };
+  }
+
+  /**
+   * Given a binding, fetch a function that's responsible for formatting, and/or de-formatting the data
+   * If no formatter is registered, it will return undefined
+   */
+  public getFormatter(
+    binding: BindingInstance
+  ): FormatDefinition<unknown, unknown> | undefined {
+    const type = this.getApparentType(binding);
+
+    if (!type?.format) {
+      return undefined;
+    }
+
+    return this.getFormatterForType(type.format);
+  }
+}