@player-ui/player 0.0.1-next.2 → 0.0.1-next.20

package/dist/index.cjs.js

@@ -12,7 +12,7 @@ var schema = require('@player-ui/schema');
 var stringResolver = require('@player-ui/string-resolver');
 var validator = require('@player-ui/validator');
 var view = require('@player-ui/view');
-var tapable = require('tapable');
+var tapableTs = require('tapable-ts');
 var timm = require('timm');
 var deferred = require('p-defer');
 var constants = require('@player-ui/constants');
@@ -197,12 +197,8 @@ var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 class ViewController {
   constructor(initialViews, options) {
     this.hooks = {
-      resolveView: new tapable.SyncWaterfallHook([
-        "view",
-        "viewRef",
-        "viewState"
-      ]),
-      view: new tapable.SyncHook(["view"])
+      resolveView: new tapableTs.SyncWaterfallHook(),
+      view: new tapableTs.SyncHook()
     };
     this.transformRegistry = new partialMatchRegistry.Registry();
     this.optimizeUpdates = true;
@@ -275,16 +271,16 @@ class ViewController {
 class DataController {
   constructor(model, options) {
     this.hooks = {
-      resolve: new tapable.SyncWaterfallHook(["binding"]),
-      resolveDataStages: new tapable.SyncWaterfallHook(["pipeline"]),
-      resolveDefaultValue: new tapable.SyncBailHook(["binding"]),
-      onDelete: new tapable.SyncHook(["binding"]),
-      onSet: new tapable.SyncHook(["transaction"]),
-      onGet: new tapable.SyncHook(["binding", "result"]),
-      onUpdate: new tapable.SyncHook(["updates"]),
-      format: new tapable.SyncWaterfallHook(["value", "binding"]),
-      deformat: new tapable.SyncWaterfallHook(["value", "binding"]),
-      serialize: new tapable.SyncWaterfallHook(["data"])
+      resolve: new tapableTs.SyncWaterfallHook(),
+      resolveDataStages: new tapableTs.SyncWaterfallHook(),
+      resolveDefaultValue: new tapableTs.SyncBailHook(),
+      onDelete: new tapableTs.SyncHook(),
+      onSet: new tapableTs.SyncHook(),
+      onGet: new tapableTs.SyncHook(),
+      onUpdate: new tapableTs.SyncHook(),
+      format: new tapableTs.SyncWaterfallHook(),
+      deformat: new tapableTs.SyncWaterfallHook(),
+      serialize: new tapableTs.SyncWaterfallHook()
     };
     this.logger = options.logger;
     const middleware = options.middleware || [];
@@ -715,9 +711,9 @@ class ValidatedBinding {
 class ValidationController {
   constructor(schema, options) {
     this.hooks = {
-      createValidatorRegistry: new tapable.SyncHook(["registry"]),
-      onAddValidation: new tapable.SyncWaterfallHook(["validation", "binding"]),
-      onRemoveValidation: new tapable.SyncWaterfallHook(["validation", "binding"])
+      createValidatorRegistry: new tapableTs.SyncHook(),
+      onAddValidation: new tapableTs.SyncWaterfallHook(),
+      onRemoveValidation: new tapableTs.SyncWaterfallHook()
     };
     this.validations = new Map();
     this.weakBindingTracker = new Set();
@@ -1040,30 +1036,26 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-const PLAYER_VERSION = "!!STABLE_VERSION!!";
-const COMMIT = "!!STABLE_GIT_COMMIT!!";
+const PLAYER_VERSION = "0.0.1-next.20";
+const COMMIT = "9bf4d566e198543d6bfb77bcade800aafed65675";
 const _Player = class {
   constructor(config) {
     this.logger = new logger.TapableLogger();
     this.constantsController = new constants.ConstantsController();
     this.state = NOT_STARTED_STATE;
     this.hooks = {
-      flowController: new tapable.SyncHook(["flowController"]),
-      viewController: new tapable.SyncHook(["viewController"]),
-      view: new tapable.SyncHook(["view"]),
-      expressionEvaluator: new tapable.SyncHook([
-        "expressionEvaluator"
-      ]),
-      dataController: new tapable.SyncHook(["dataController"]),
-      schema: new tapable.SyncHook(["schema"]),
-      validationController: new tapable.SyncHook([
-        "validationController"
-      ]),
-      bindingParser: new tapable.SyncHook(["bindingParser"]),
-      state: new tapable.SyncHook(["state"]),
-      onStart: new tapable.SyncHook(["flow"]),
-      onEnd: new tapable.SyncHook(),
-      resolveFlowContent: new tapable.SyncWaterfallHook(["content"])
+      flowController: new tapableTs.SyncHook(),
+      viewController: new tapableTs.SyncHook(),
+      view: new tapableTs.SyncHook(),
+      expressionEvaluator: new tapableTs.SyncHook(),
+      dataController: new tapableTs.SyncHook(),
+      schema: new tapableTs.SyncHook(),
+      validationController: new tapableTs.SyncHook(),
+      bindingParser: new tapableTs.SyncHook(),
+      state: new tapableTs.SyncHook(),
+      onStart: new tapableTs.SyncHook(),
+      onEnd: new tapableTs.SyncHook(),
+      resolveFlowContent: new tapableTs.SyncWaterfallHook()
     };
     var _a;
     const initialPlugins = [];

package/dist/index.d.ts

@@ -18,7 +18,7 @@ import { ValidatorRegistry, ValidationResponse, ValidatorContext, ValidationObje
 export * from '@player-ui/validator';
 import { Node, Resolve, ViewPlugin, Resolver, ViewInstance } from '@player-ui/view';
 export * from '@player-ui/view';
-import { SyncHook, SyncWaterfallHook, SyncBailHook } from 'tapable';
+import { SyncHook, SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
 import { ConstantsController } from '@player-ui/constants';
 import { Registry } from '@player-ui/partial-match-registry';
 
@@ -151,11 +151,11 @@ declare class ValidatedBinding {
 declare class ValidationController implements BindingTracker {
     readonly hooks: {
         /** A hook called to tap into the validator registry for adding more validators */
-        createValidatorRegistry: SyncHook<ValidatorRegistry, any, any>;
+        createValidatorRegistry: SyncHook<[ValidatorRegistry], Record<string, any>>;
         /** A callback/event when a new validation is added to the view */
-        onAddValidation: SyncWaterfallHook<ValidationResponse, BindingInstance, any>;
+        onAddValidation: SyncWaterfallHook<[ValidationResponse, BindingInstance], Record<string, any>>;
         /** The inverse of onAddValidation, this is called when a validation is removed from the list */
-        onRemoveValidation: SyncWaterfallHook<ValidationResponse, BindingInstance, any>;
+        onRemoveValidation: SyncWaterfallHook<[ValidationResponse, BindingInstance], Record<string, any>>;
     };
     private tracker;
     private validations;
@@ -254,16 +254,16 @@ declare type RawSetTransaction = Record<string, any> | RawSetType[];
 /** The orchestrator for player data */
 declare class DataController implements DataModelWithParser<DataModelOptions> {
     hooks: {
-        resolve: SyncWaterfallHook<any, any, any>;
-        resolveDataStages: SyncWaterfallHook<DataPipeline, any, any>;
-        resolveDefaultValue: SyncBailHook<BindingInstance, any, any, any>;
-        onDelete: SyncHook<any, void, any>;
-        onSet: SyncHook<BatchSetTransaction, void, any>;
-        onGet: SyncHook<any, any, void>;
-        onUpdate: SyncHook<Updates, any, any>;
-        format: SyncWaterfallHook<any, BindingInstance, any>;
-        deformat: SyncWaterfallHook<any, BindingInstance, any>;
-        serialize: SyncWaterfallHook<any, any, any>;
+        resolve: SyncWaterfallHook<any[], Record<string, any>>;
+        resolveDataStages: SyncWaterfallHook<[DataPipeline], Record<string, any>>;
+        resolveDefaultValue: SyncBailHook<[BindingInstance], any, Record<string, any>>;
+        onDelete: SyncHook<[any], Record<string, any>>;
+        onSet: SyncHook<[BatchSetTransaction], Record<string, any>>;
+        onGet: SyncHook<[any, any], Record<string, any>>;
+        onUpdate: SyncHook<[Updates], Record<string, any>>;
+        format: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
+        deformat: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
+        serialize: SyncWaterfallHook<[any], Record<string, any>>;
     };
     private model?;
     private trash;
@@ -302,10 +302,10 @@ interface ViewControllerOptions {
 declare class ViewController {
     readonly hooks: {
         /** Do any processing before the `View` instance is created */
-        resolveView: SyncWaterfallHook<_player_ui_types.Asset<string> & {
+        resolveView: SyncWaterfallHook<[(_player_ui_types.Asset<string> & {
             validation?: _player_ui_types.Validation.CrossfieldReference[] | undefined;
-        }, string, NavigationFlowViewState>;
-        view: SyncHook<ViewInstance, any, any>;
+        }) | undefined, string, NavigationFlowViewState], Record<string, any>>;
+        view: SyncHook<[ViewInstance], Record<string, any>>;
     };
     private readonly viewMap;
     private readonly viewOptions;
@@ -370,29 +370,29 @@ declare class Player {
     private state;
     readonly hooks: {
         /** The hook that fires every time we create a new flowController (a new Content blob is passed in) */
-        flowController: SyncHook<FlowController, any, any>;
+        flowController: SyncHook<[FlowController], Record<string, any>>;
         /** The hook that updates/handles views */
-        viewController: SyncHook<ViewController, any, any>;
+        viewController: SyncHook<[ViewController], Record<string, any>>;
         /** A hook called every-time there's a new view. This is equivalent to the view hook on the view-controller */
-        view: SyncHook<ViewInstance, any, any>;
+        view: SyncHook<[ViewInstance], Record<string, any>>;
         /** Called when an expression evaluator was created */
-        expressionEvaluator: SyncHook<ExpressionEvaluator, any, any>;
+        expressionEvaluator: SyncHook<[ExpressionEvaluator], Record<string, any>>;
         /** The hook that creates and manages data */
-        dataController: SyncHook<DataController, any, any>;
+        dataController: SyncHook<[DataController], Record<string, any>>;
         /** Called after the schema is created for a flow */
-        schema: SyncHook<SchemaController, any, any>;
+        schema: SyncHook<[SchemaController], Record<string, any>>;
         /** Manages validations (schema and x-field ) */
-        validationController: SyncHook<ValidationController, any, any>;
+        validationController: SyncHook<[ValidationController], Record<string, any>>;
         /** Manages parsing binding */
-        bindingParser: SyncHook<BindingParser, any, any>;
+        bindingParser: SyncHook<[BindingParser], Record<string, any>>;
         /** A that's called for state changes in the flow execution */
-        state: SyncHook<PlayerFlowState, any, any>;
+        state: SyncHook<[PlayerFlowState], Record<string, any>>;
         /** A hook to access the current flow */
-        onStart: SyncHook<Flow<_player_ui_types.Asset<string>>, any, any>;
+        onStart: SyncHook<[Flow<_player_ui_types.Asset<string>>], Record<string, any>>;
         /** A hook for when the flow ends either in success or failure */
-        onEnd: SyncHook<any, any, any>;
+        onEnd: SyncHook<[], Record<string, any>>;
         /** Mutate the Content flow before starting */
-        resolveFlowContent: SyncWaterfallHook<Flow<_player_ui_types.Asset<string>>, any, any>;
+        resolveFlowContent: SyncWaterfallHook<[Flow<_player_ui_types.Asset<string>>], Record<string, any>>;
     };
     constructor(config?: PlayerConfigOptions);
     /** Find instance of [Plugin] that has been registered to Player */

package/dist/index.esm.js

@@ -17,7 +17,7 @@ import { ValidationMiddleware, ValidatorRegistry } from '@player-ui/validator';
 export * from '@player-ui/validator';
 import { NodeType, ViewInstance, caresAboutDataChanges } from '@player-ui/view';
 export * from '@player-ui/view';
-import { SyncWaterfallHook, SyncHook, SyncBailHook } from 'tapable';
+import { SyncWaterfallHook, SyncHook, SyncBailHook } from 'tapable-ts';
 import { removeAt, omit, setIn } from 'timm';
 import deferred from 'p-defer';
 import { ConstantsController } from '@player-ui/constants';
@@ -197,12 +197,8 @@ var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 class ViewController {
   constructor(initialViews, options) {
     this.hooks = {
-      resolveView: new SyncWaterfallHook([
-        "view",
-        "viewRef",
-        "viewState"
-      ]),
-      view: new SyncHook(["view"])
+      resolveView: new SyncWaterfallHook(),
+      view: new SyncHook()
     };
     this.transformRegistry = new Registry();
     this.optimizeUpdates = true;
@@ -275,16 +271,16 @@ class ViewController {
 class DataController {
   constructor(model, options) {
     this.hooks = {
-      resolve: new SyncWaterfallHook(["binding"]),
-      resolveDataStages: new SyncWaterfallHook(["pipeline"]),
-      resolveDefaultValue: new SyncBailHook(["binding"]),
-      onDelete: new SyncHook(["binding"]),
-      onSet: new SyncHook(["transaction"]),
-      onGet: new SyncHook(["binding", "result"]),
-      onUpdate: new SyncHook(["updates"]),
-      format: new SyncWaterfallHook(["value", "binding"]),
-      deformat: new SyncWaterfallHook(["value", "binding"]),
-      serialize: new SyncWaterfallHook(["data"])
+      resolve: new SyncWaterfallHook(),
+      resolveDataStages: new SyncWaterfallHook(),
+      resolveDefaultValue: new SyncBailHook(),
+      onDelete: new SyncHook(),
+      onSet: new SyncHook(),
+      onGet: new SyncHook(),
+      onUpdate: new SyncHook(),
+      format: new SyncWaterfallHook(),
+      deformat: new SyncWaterfallHook(),
+      serialize: new SyncWaterfallHook()
     };
     this.logger = options.logger;
     const middleware = options.middleware || [];
@@ -715,9 +711,9 @@ class ValidatedBinding {
 class ValidationController {
   constructor(schema, options) {
     this.hooks = {
-      createValidatorRegistry: new SyncHook(["registry"]),
-      onAddValidation: new SyncWaterfallHook(["validation", "binding"]),
-      onRemoveValidation: new SyncWaterfallHook(["validation", "binding"])
+      createValidatorRegistry: new SyncHook(),
+      onAddValidation: new SyncWaterfallHook(),
+      onRemoveValidation: new SyncWaterfallHook()
     };
     this.validations = new Map();
     this.weakBindingTracker = new Set();
@@ -1040,30 +1036,26 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-const PLAYER_VERSION = "!!STABLE_VERSION!!";
-const COMMIT = "!!STABLE_GIT_COMMIT!!";
+const PLAYER_VERSION = "0.0.1-next.20";
+const COMMIT = "9bf4d566e198543d6bfb77bcade800aafed65675";
 const _Player = class {
   constructor(config) {
     this.logger = new TapableLogger();
     this.constantsController = new ConstantsController();
     this.state = NOT_STARTED_STATE;
     this.hooks = {
-      flowController: new SyncHook(["flowController"]),
-      viewController: new SyncHook(["viewController"]),
-      view: new SyncHook(["view"]),
-      expressionEvaluator: new SyncHook([
-        "expressionEvaluator"
-      ]),
-      dataController: new SyncHook(["dataController"]),
-      schema: new SyncHook(["schema"]),
-      validationController: new SyncHook([
-        "validationController"
-      ]),
-      bindingParser: new SyncHook(["bindingParser"]),
-      state: new SyncHook(["state"]),
-      onStart: new SyncHook(["flow"]),
+      flowController: new SyncHook(),
+      viewController: new SyncHook(),
+      view: new SyncHook(),
+      expressionEvaluator: new SyncHook(),
+      dataController: new SyncHook(),
+      schema: new SyncHook(),
+      validationController: new SyncHook(),
+      bindingParser: new SyncHook(),
+      state: new SyncHook(),
+      onStart: new SyncHook(),
       onEnd: new SyncHook(),
-      resolveFlowContent: new SyncWaterfallHook(["content"])
+      resolveFlowContent: new SyncWaterfallHook()
     };
     var _a;
     const initialPlugins = [];

package/package.json

@@ -1,26 +1,74 @@
 {
   "name": "@player-ui/player",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.20",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {},
   "dependencies": {
-    "@player-ui/binding-grammar": "0.0.1-next.2",
-    "@player-ui/logger": "0.0.1-next.2",
-    "@player-ui/partial-match-registry": "0.0.1-next.2",
-    "@player-ui/types": "0.0.1-next.2",
-    "@player-ui/utils": "0.0.1-next.2",
+    "@player-ui/binding": "0.0.1-next.20",
+    "@player-ui/constants": "0.0.1-next.20",
+    "@player-ui/data": "0.0.1-next.20",
+    "@player-ui/expressions": "0.0.1-next.20",
+    "@player-ui/flow": "0.0.1-next.20",
+    "@player-ui/logger": "0.0.1-next.20",
+    "@player-ui/partial-match-registry": "0.0.1-next.20",
+    "@player-ui/schema": "0.0.1-next.20",
+    "@player-ui/string-resolver": "0.0.1-next.20",
+    "@player-ui/types": "0.0.1-next.20",
+    "@player-ui/utils": "0.0.1-next.20",
+    "@player-ui/validator": "0.0.1-next.20",
+    "@player-ui/view": "0.0.1-next.20",
     "babel-plugin-preval": "^5.0.0",
     "dequal": "^2.0.2",
     "p-defer": "^3.0.0",
     "queue-microtask": "^1.2.3",
-    "tapable": "1.1.3",
+    "tapable-ts": "^0.1.0",
     "timm": "^1.6.2",
     "@babel/runtime": "7.15.4"
   },
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
-  "typings": "dist/index.d.ts"
+  "typings": "dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/player-ui/player-ui"
+  },
+  "bugs": {
+    "url": "https://github.com/player-ui/player-ui/issues"
+  },
+  "homepage": "https://player-ui.github.io",
+  "contributors": [
+    {
+      "name": "Adam Dierkens",
+      "url": "https://github.com/adierkens"
+    },
+    {
+      "name": "Spencer Hamm",
+      "url": "https://github.com/spentacular"
+    },
+    {
+      "name": "Harris Borawski",
+      "url": "https://github.com/hborawski"
+    },
+    {
+      "name": "Jeremiah Zucker",
+      "url": "https://github.com/sugarmanz"
+    },
+    {
+      "name": "Ketan Reddy",
+      "url": "https://github.com/KetanReddy"
+    },
+    {
+      "name": "Brocollie08",
+      "url": "https://github.com/brocollie08"
+    },
+    {
+      "name": "Kelly Harrop",
+      "url": "https://github.com/kharrop"
+    }
+  ]
 }

package/src/data.ts

@@ -1,4 +1,4 @@
-import { SyncHook, SyncWaterfallHook, SyncBailHook } from 'tapable';
+import { SyncHook, SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
 import type { Logger } from '@player-ui/logger';
 import { omit, removeAt } from 'timm';
 import { dequal } from 'dequal';
@@ -18,21 +18,21 @@ import type { RawSetTransaction } from './types';
 /** The orchestrator for player data */
 export class DataController implements DataModelWithParser<DataModelOptions> {
   public hooks = {
-    resolve: new SyncWaterfallHook(['binding']),
-    resolveDataStages: new SyncWaterfallHook<DataPipeline>(['pipeline']),
+    resolve: new SyncWaterfallHook(),
+    resolveDataStages: new SyncWaterfallHook<[DataPipeline]>(),
 
     // On any set or get of an undefined value, redirect the value to be the default
-    resolveDefaultValue: new SyncBailHook<BindingInstance, any>(['binding']),
+    resolveDefaultValue: new SyncBailHook<[BindingInstance], any>(),
 
-    onDelete: new SyncHook<any, void>(['binding']),
-    onSet: new SyncHook<BatchSetTransaction, void>(['transaction']),
-    onGet: new SyncHook<any, any, void>(['binding', 'result']),
-    onUpdate: new SyncHook<Updates>(['updates']),
+    onDelete: new SyncHook<[any]>(),
+    onSet: new SyncHook<[BatchSetTransaction]>(),
+    onGet: new SyncHook<[any, any]>(),
+    onUpdate: new SyncHook<[Updates]>(),
 
-    format: new SyncWaterfallHook<any, BindingInstance>(['value', 'binding']),
-    deformat: new SyncWaterfallHook<any, BindingInstance>(['value', 'binding']),
+    format: new SyncWaterfallHook<[any, BindingInstance]>(),
+    deformat: new SyncWaterfallHook<[any, BindingInstance]>(),
 
-    serialize: new SyncWaterfallHook<any>(['data']),
+    serialize: new SyncWaterfallHook<[any]>(),
   };
 
   private model?: PipelinedDataModel;

package/src/player.ts

@@ -1,4 +1,4 @@
-import { SyncHook, SyncWaterfallHook } from 'tapable';
+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';
@@ -27,8 +27,8 @@ import type {
 import { NOT_STARTED_STATE } from './types';
 
 // Variables injected at build time
-const PLAYER_VERSION = '!!STABLE_VERSION!!';
-const COMMIT = '!!STABLE_GIT_COMMIT!!';
+const PLAYER_VERSION = '0.0.1-next.20';
+const COMMIT = '9bf4d566e198543d6bfb77bcade800aafed65675';
 
 export interface PlayerPlugin {
   /**
@@ -78,43 +78,39 @@ export class Player {
 
   public readonly hooks = {
     /** The hook that fires every time we create a new flowController (a new Content blob is passed in) */
-    flowController: new SyncHook<FlowController>(['flowController']),
+    flowController: new SyncHook<[FlowController]>(),
 
     /** The hook that updates/handles views */
-    viewController: new SyncHook<ViewController>(['viewController']),
+    viewController: new SyncHook<[ViewController]>(),
 
     /** A hook called every-time there's a new view. This is equivalent to the view hook on the view-controller */
-    view: new SyncHook<ViewInstance>(['view']),
+    view: new SyncHook<[ViewInstance]>(),
 
     /** Called when an expression evaluator was created */
-    expressionEvaluator: new SyncHook<ExpressionEvaluator>([
-      'expressionEvaluator',
-    ]),
+    expressionEvaluator: new SyncHook<[ExpressionEvaluator]>(),
 
     /** The hook that creates and manages data */
-    dataController: new SyncHook<DataController>(['dataController']),
+    dataController: new SyncHook<[DataController]>(),
 
     /** Called after the schema is created for a flow */
-    schema: new SyncHook<SchemaController>(['schema']),
+    schema: new SyncHook<[SchemaController]>(),
 
     /** Manages validations (schema and x-field ) */
-    validationController: new SyncHook<ValidationController>([
-      'validationController',
-    ]),
+    validationController: new SyncHook<[ValidationController]>(),
 
     /** Manages parsing binding */
-    bindingParser: new SyncHook<BindingParser>(['bindingParser']),
+    bindingParser: new SyncHook<[BindingParser]>(),
 
     /** A that's called for state changes in the flow execution */
-    state: new SyncHook<PlayerFlowState>(['state']),
+    state: new SyncHook<[PlayerFlowState]>(),
 
     /** A hook to access the current flow */
-    onStart: new SyncHook<FlowType>(['flow']),
+    onStart: new SyncHook<[FlowType]>(),
 
     /** A hook for when the flow ends either in success or failure */
-    onEnd: new SyncHook(),
+    onEnd: new SyncHook<[]>(),
     /** Mutate the Content flow before starting */
-    resolveFlowContent: new SyncWaterfallHook<FlowType>(['content']),
+    resolveFlowContent: new SyncWaterfallHook<[FlowType]>(),
   };
 
   constructor(config?: PlayerConfigOptions) {

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

@@ -1,4 +1,8 @@
-import type { Expression, ExpressionObject } from '@player-ui/types';
+import type {
+  Expression,
+  ExpressionObject,
+  NavigationFlowState,
+} from '@player-ui/types';
 import type { ExpressionEvaluator } from '@player-ui/expressions';
 import type { FlowInstance } from '@player-ui/flow';
 import type { Player, PlayerPlugin } from '../player';
@@ -42,7 +46,7 @@ export class FlowExpPlugin implements PlayerPlugin {
         flow.hooks.onEnd.tap(this.name, (exp) => handleEval(exp));
         // Eval state nodes
         flow.hooks.resolveTransitionNode.intercept({
-          call: (nextState) => {
+          call: (nextState: NavigationFlowState) => {
             /** Get the current state of Player */
             const currentState = () => player.getState() as InProgressState;
 

package/src/validation/controller.ts

@@ -22,7 +22,7 @@ import type {
   ExpressionEvaluatorOptions,
   ExpressionType,
 } from '@player-ui/expressions';
-import { SyncHook, SyncWaterfallHook } from 'tapable';
+import { SyncHook, SyncWaterfallHook } from 'tapable-ts';
 import type { BindingTracker } from './binding-tracker';
 import { ValidationBindingTrackerViewPlugin } from './binding-tracker';
 
@@ -279,18 +279,17 @@ class ValidatedBinding {
 export class ValidationController implements BindingTracker {
   public readonly hooks = {
     /** A hook called to tap into the validator registry for adding more validators */
-    createValidatorRegistry: new SyncHook<ValidatorRegistry>(['registry']),
+    createValidatorRegistry: new SyncHook<[ValidatorRegistry]>(),
 
     /** A callback/event when a new validation is added to the view */
-    onAddValidation: new SyncWaterfallHook<ValidationResponse, BindingInstance>(
-      ['validation', 'binding']
-    ),
+    onAddValidation: new SyncWaterfallHook<
+      [ValidationResponse, BindingInstance]
+    >(),
 
     /** The inverse of onAddValidation, this is called when a validation is removed from the list */
     onRemoveValidation: new SyncWaterfallHook<
-      ValidationResponse,
-      BindingInstance
-    >(['validation', 'binding']),
+      [ValidationResponse, BindingInstance]
+    >(),
   };
 
   private tracker: BindingTracker | undefined;

package/src/view/controller.ts

@@ -1,4 +1,4 @@
-import { SyncHook, SyncWaterfallHook } from 'tapable';
+import { SyncHook, SyncWaterfallHook } from 'tapable-ts';
 import type { Resolve } from '@player-ui/view';
 import { ViewInstance } from '@player-ui/view';
 import type { Logger } from '@player-ui/logger';
@@ -27,14 +27,12 @@ export interface ViewControllerOptions {
 export class ViewController {
   public readonly hooks = {
     /** Do any processing before the `View` instance is created */
-    resolveView: new SyncWaterfallHook<View, string, NavigationFlowViewState>([
-      'view',
-      'viewRef',
-      'viewState',
-    ]),
+    resolveView: new SyncWaterfallHook<
+      [View | undefined, string, NavigationFlowViewState]
+    >(),
 
     // The hook right before the View starts resolving. Attach anything custom here
-    view: new SyncHook<ViewInstance>(['view']),
+    view: new SyncHook<[ViewInstance]>(),
   };
 
   private readonly viewMap: Record<string, View>;