[middleware] Refactor createMiddleware

Author: jamesgpearce

coverage.json

@@ -1 +1 @@
-{"tests":7636,"assertions":32830,"lines":{"total":2560,"covered":2560,"skipped":0,"pct":100},"statements":{"total":2785,"covered":2785,"skipped":0,"pct":100},"functions":{"total":1137,"covered":1137,"skipped":0,"pct":100},"branches":{"total":971,"covered":971,"skipped":0,"pct":100},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":100}}
+{"tests":7636,"assertions":32830,"lines":{"total":2539,"covered":2539,"skipped":0,"pct":100},"statements":{"total":2750,"covered":2750,"skipped":0,"pct":100},"functions":{"total":1101,"covered":1101,"skipped":0,"pct":100},"branches":{"total":957,"covered":957,"skipped":0,"pct":100},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":100}}

src/middleware/index.ts

@@ -35,8 +35,35 @@ import {getCreateFunction} from '../common/definable.ts';
 import {objFreeze} from '../common/obj.ts';
 import {isUndefined} from '../common/other.ts';
 
+const reduceCallbacks = (
+  callbacks: ((...args: any[]) => any)[],
+  thing: any,
+  ...ids: Id[]
+): any =>
+  arrayReduce(
+    callbacks,
+    (current, callback) =>
+      isUndefined(current) ? current : callback(...ids, current),
+    thing,
+  );
+
+const everyCallback = (
+  callbacks: ((...args: any[]) => boolean)[],
+  ...ids: Id[]
+): boolean => arrayEvery(callbacks, (callback) => callback(...ids));
+
 export const createMiddleware = getCreateFunction(
   (store: Store): Middleware => {
+    const fluent = (actions: () => void): Middleware => {
+      actions();
+      return middleware;
+    };
+
+    const addCallback =
+      <Callback>(callbacks: Callback[]) =>
+      (callback: Callback): Middleware =>
+        fluent(() => arrayPush(callbacks, callback));
+
     const willSetContentCallbacks: WillSetContentCallback[] = [];
     const willSetTablesCallbacks: WillSetTablesCallback[] = [];
     const willSetTableCallbacks: WillSetTableCallback[] = [];
@@ -52,106 +79,50 @@ export const createMiddleware = getCreateFunction(
     const willDelValueCallbacks: WillDelValueCallback[] = [];
     const willApplyChangesCallbacks: WillApplyChangesCallback[] = [];
 
-    const willSetContent = (
-      content: Content,
-    ): Content | undefined =>
-      arrayReduce(
-        willSetContentCallbacks,
-        (current, callback) =>
-          isUndefined(current)
-            ? current
-            : callback(current as Content),
-        content as Content | undefined,
-      );
+    const willSetContent = (content: Content): Content | undefined =>
+      reduceCallbacks(willSetContentCallbacks, content);
 
     const willSetTables = (tables: Tables): Tables | undefined =>
-      arrayReduce(
-        willSetTablesCallbacks,
-        (current, callback) =>
-          isUndefined(current) ? current : callback(current as Tables),
-        tables as Tables | undefined,
-      );
+      reduceCallbacks(willSetTablesCallbacks, tables);
 
     const willSetTable = (tableId: Id, table: Table): Table | undefined =>
-      arrayReduce(
-        willSetTableCallbacks,
-        (current, callback) =>
-          isUndefined(current) ? current : callback(tableId, current as Table),
-        table as Table | undefined,
-      );
+      reduceCallbacks(willSetTableCallbacks, table, tableId);
 
     const willSetRow = (tableId: Id, rowId: Id, row: Row): Row | undefined =>
-      arrayReduce(
-        willSetRowCallbacks,
-        (current, callback) =>
-          isUndefined(current)
-            ? current
-            : callback(tableId, rowId, current as Row),
-        row as Row | undefined,
-      );
+      reduceCallbacks(willSetRowCallbacks, row, tableId, rowId);
 
     const willSetCell = (
       tableId: Id,
       rowId: Id,
       cellId: Id,
       cell: Cell,
     ): CellOrUndefined =>
-      arrayReduce(
-        willSetCellCallbacks,
-        (current, callback) =>
-          isUndefined(current)
-            ? current
-            : callback(tableId, rowId, cellId, current as Cell),
-        cell as CellOrUndefined,
-      );
+      reduceCallbacks(willSetCellCallbacks, cell, tableId, rowId, cellId);
 
     const willSetValues = (values: Values): Values | undefined =>
-      arrayReduce(
-        willSetValuesCallbacks,
-        (current, callback) =>
-          isUndefined(current) ? current : callback(current as Values),
-        values as Values | undefined,
-      );
+      reduceCallbacks(willSetValuesCallbacks, values);
 
     const willSetValue = (valueId: Id, value: Value): ValueOrUndefined =>
-      arrayReduce(
-        willSetValueCallbacks,
-        (current, callback) =>
-          isUndefined(current) ? current : callback(valueId, current as Value),
-        value as ValueOrUndefined,
-      );
+      reduceCallbacks(willSetValueCallbacks, value, valueId);
 
-    const willDelTables = (): boolean =>
-      arrayEvery(willDelTablesCallbacks, (callback) => callback());
+    const willDelTables = (): boolean => everyCallback(willDelTablesCallbacks);
 
     const willDelTable = (tableId: Id): boolean =>
-      arrayEvery(willDelTableCallbacks, (callback) => callback(tableId));
+      everyCallback(willDelTableCallbacks, tableId);
 
     const willDelRow = (tableId: Id, rowId: Id): boolean =>
-      arrayEvery(willDelRowCallbacks, (callback) => callback(tableId, rowId));
+      everyCallback(willDelRowCallbacks, tableId, rowId);
 
     const willDelCell = (tableId: Id, rowId: Id, cellId: Id): boolean =>
-      arrayEvery(willDelCellCallbacks, (callback) =>
-        callback(tableId, rowId, cellId),
-      );
+      everyCallback(willDelCellCallbacks, tableId, rowId, cellId);
 
-    const willDelValues = (): boolean =>
-      arrayEvery(willDelValuesCallbacks, (callback) => callback());
+    const willDelValues = (): boolean => everyCallback(willDelValuesCallbacks);
 
     const willDelValue = (valueId: Id): boolean =>
-      arrayEvery(willDelValueCallbacks, (callback) => callback(valueId));
+      everyCallback(willDelValueCallbacks, valueId);
 
-    const willApplyChanges = (
-      changes: Changes,
-    ): Changes | undefined =>
-      arrayReduce(
-        willApplyChangesCallbacks,
-        (current, callback) =>
-          isUndefined(current)
-            ? current
-            : callback(current as Changes),
-        changes as Changes | undefined,
-      );
+    const willApplyChanges = (changes: Changes): Changes | undefined =>
+      reduceCallbacks(willApplyChangesCallbacks, changes);
 
     (store as any).setWillCallbacks(
       willSetContent,
@@ -172,66 +143,20 @@ export const createMiddleware = getCreateFunction(
 
     const getStore = (): Store => store;
 
-    const fluent = (actions: () => void): Middleware => {
-      actions();
-      return middleware;
-    };
-
-    const addWillSetContentCallback = (
-      callback: WillSetContentCallback,
-    ): Middleware =>
-      fluent(() => arrayPush(willSetContentCallbacks, callback));
-
-    const addWillSetTablesCallback = (
-      callback: WillSetTablesCallback,
-    ): Middleware => fluent(() => arrayPush(willSetTablesCallbacks, callback));
-
-    const addWillSetTableCallback = (
-      callback: WillSetTableCallback,
-    ): Middleware => fluent(() => arrayPush(willSetTableCallbacks, callback));
-
-    const addWillSetRowCallback = (callback: WillSetRowCallback): Middleware =>
-      fluent(() => arrayPush(willSetRowCallbacks, callback));
-
-    const addWillSetCellCallback = (
-      callback: WillSetCellCallback,
-    ): Middleware => fluent(() => arrayPush(willSetCellCallbacks, callback));
-
-    const addWillSetValuesCallback = (
-      callback: WillSetValuesCallback,
-    ): Middleware => fluent(() => arrayPush(willSetValuesCallbacks, callback));
-
-    const addWillSetValueCallback = (
-      callback: WillSetValueCallback,
-    ): Middleware => fluent(() => arrayPush(willSetValueCallbacks, callback));
-
-    const addWillDelTablesCallback = (
-      callback: WillDelTablesCallback,
-    ): Middleware => fluent(() => arrayPush(willDelTablesCallbacks, callback));
-
-    const addWillDelTableCallback = (
-      callback: WillDelTableCallback,
-    ): Middleware => fluent(() => arrayPush(willDelTableCallbacks, callback));
-
-    const addWillDelRowCallback = (callback: WillDelRowCallback): Middleware =>
-      fluent(() => arrayPush(willDelRowCallbacks, callback));
-
-    const addWillDelCellCallback = (
-      callback: WillDelCellCallback,
-    ): Middleware => fluent(() => arrayPush(willDelCellCallbacks, callback));
-
-    const addWillDelValuesCallback = (
-      callback: WillDelValuesCallback,
-    ): Middleware => fluent(() => arrayPush(willDelValuesCallbacks, callback));
-
-    const addWillDelValueCallback = (
-      callback: WillDelValueCallback,
-    ): Middleware => fluent(() => arrayPush(willDelValueCallbacks, callback));
-
-    const addWillApplyChangesCallback = (
-      callback: WillApplyChangesCallback,
-    ): Middleware =>
-      fluent(() => arrayPush(willApplyChangesCallbacks, callback));
+    const addWillSetContentCallback = addCallback(willSetContentCallbacks);
+    const addWillSetTablesCallback = addCallback(willSetTablesCallbacks);
+    const addWillSetTableCallback = addCallback(willSetTableCallbacks);
+    const addWillSetRowCallback = addCallback(willSetRowCallbacks);
+    const addWillSetCellCallback = addCallback(willSetCellCallbacks);
+    const addWillSetValuesCallback = addCallback(willSetValuesCallbacks);
+    const addWillSetValueCallback = addCallback(willSetValueCallbacks);
+    const addWillDelTablesCallback = addCallback(willDelTablesCallbacks);
+    const addWillDelTableCallback = addCallback(willDelTableCallbacks);
+    const addWillDelRowCallback = addCallback(willDelRowCallbacks);
+    const addWillDelCellCallback = addCallback(willDelCellCallbacks);
+    const addWillDelValuesCallback = addCallback(willDelValuesCallbacks);
+    const addWillDelValueCallback = addCallback(willDelValueCallbacks);
+    const addWillApplyChangesCallback = addCallback(willApplyChangesCallbacks);
 
     const destroy = (): void => {};