riducers 1.2.4 → 2.0.0

package/src/index.ts

@@ -1,228 +1,244 @@
-type Id = number | string;
+import { ReducerOpts, ReducerAction, ModelObj, SortFn } from "./types";
+import { mapInsertReducer, mapDeleteReducer, mapReplaceReducer } from "./mapReducers";
+import {
+  listInsertReducer,
+  listUnshiftReducer,
+  listSortReducer,
+  listDeleteReducer,
+  listShiftReducer,
+  listReplaceReducer
+} from "./listReducers";
+import {
+  mapListInsertReducer,
+  mapListDeleteReducer,
+  mapListReplaceReducer,
+  mapListSortReducer,
+  mapListShiftReducer,
+  mapListUnshiftReducer,
+  MapListState
+} from "./mapListReducers";
+import { objInsertReducer, objReplaceReducer, objDeleteReducer } from "./objReducers";
+
+// Re-export types for external usage
+export * from "./types";
+export { keySort } from "./helpers";
 
-interface ModelObj {
-  [key: string]: any;
-}
-
-type SortFn = (a: ModelObj, b: ModelObj) => number;
-
-interface ListAction {
-  payload: ModelObj | ModelObj[];
-  sort?: SortFn;
-  keyName: string;
-  mapKeyName?: string;
-  isMapList: boolean;
-}
-
-interface MapAction {
-  payload: ModelObj | ModelObj[];
-  sort?: SortFn;
-  keyName: string;
-}
-
-interface ListSortAction {
-  sort?: SortFn;
-  keyName: string;
-  mapKeyName?: string;
-  isMapList: boolean;
-}
-
-const keySort = (key: string) => (a: ModelObj, b: ModelObj) => {
-  if (typeof a[key] === "number" && typeof b[key] === "number") return a[key] - b[key];
-  else if (typeof a[key] === "string" && typeof b[key] === "string") return a[key].localeCompare(b[key]);
-  return 0;
-};
+const OPS = ["insert", "replace", "delete", "clear", "sort"];
 
-const mapInsertReducer = (state: ModelObj, action: MapAction) => {
-  if (!state) state = {};
-  let resp: ModelObj[] = Array.isArray(action.payload) ? action.payload : [action.payload];
-  let newState = { ...state };
-  for (let i in resp) {
-    if (resp[i]?.[action.keyName]) newState[resp[i][action.keyName]] = { ...resp[i] };
+/**
+ * Gets the default initial state based on state type
+ */
+const getDefaultInitialState = (stateType: string): any => {
+  switch (stateType) {
+    case "list":
+      return [];
+    case "map":
+      return {};
+    default:
+      return null;
   }
-  return newState;
 };
 
-const mapDeleteReducer = (state: ModelObj, action: MapAction) => {
-  if (!state) state = {};
-  let resp: ModelObj[] = Array.isArray(action.payload) ? action.payload : [action.payload];
-  let newState = { ...state };
-  for (let i in resp) {
-    delete newState[resp[i][action.keyName]];
+/**
+ * Handles map-specific operation normalization
+ * When using map type, allows using the key as the operation (e.g., "users/123" for insert/delete)
+ */
+const normalizeMapOperation = (
+  op: string,
+  payload: any,
+  keyName: string
+): { op: string; payload: any } => {
+  if (!OPS.includes(op)) {
+    if (payload && !Array.isArray(payload)) {
+      payload[keyName] = op;
+      return { op: "insert", payload };
+    }
+    if (!payload) {
+      const newPayload: ModelObj = { [keyName]: op };
+      return { op: "delete", payload: newPayload };
+    }
   }
-  return newState;
+  return { op, payload };
 };
 
-const mapReplaceReducer = (state: ModelObj, action: MapAction) => {
-  let newState = {} as any;
-  let resp: ModelObj[] = Array.isArray(action.payload) ? action.payload : [action.payload];
-  for (let i in resp) {
-    if (resp[i]?.[action.keyName]) newState[resp[i][action.keyName]] = { ...resp[i] };
+/**
+ * Handles list operations (insert, replace, delete, shift, sort)
+ */
+const handleListOperation = (
+  state: ModelObj[],
+  op: string,
+  payload: any,
+  sort: SortFn | undefined,
+  keyName: string,
+  initialState: any
+): ModelObj[] | undefined => {
+  const isMapList = false;
+  switch (op) {
+    case "insert":
+      if (payload) return listInsertReducer(state, { payload, sort, keyName, isMapList });
+      break;
+    case "unshift":
+      if (payload) return listUnshiftReducer(state, { payload, sort, keyName, isMapList });
+      break;
+    case "replace":
+      return listReplaceReducer(state, { payload, sort, keyName, isMapList });
+    case "delete":
+      return listDeleteReducer(state, { payload, keyName, isMapList });
+    case "shift":
+      return listShiftReducer(state);
+    case "clear":
+      return initialState;
+    case "sort":
+      return listSortReducer(state, { sort, keyName, isMapList });
   }
-  return newState;
+  return undefined;
 };
 
-const listInsertReducer = (state: ModelObj[], action: ListAction) => {
-  if (!state) state = [];
-  let resp: ModelObj[] = Array.isArray(action.payload) ? action.payload : [action.payload];
-
-  let newState = [...state];
-  let respMap: Id[] = resp.map((r: any) => r[action.keyName]);
-  let stateMap: Id[] = newState.map((r: any) => r[action.keyName]);
-  let toInsert: Id[] = respMap.filter((id: number | string) => stateMap.indexOf(id) < 0);
-  let toReplace: Id[] = respMap.filter((id: number | string) => stateMap.indexOf(id) >= 0);
-  for (let i in toReplace) {
-    let stateIndex = stateMap.indexOf(toReplace[i]);
-    let respIndex = respMap.indexOf(toReplace[i]);
-    newState[stateIndex] = { ...resp[respIndex] };
-  }
-  if (toInsert.length > 0) {
-    let inserts = toInsert.map((id: number | string) => resp[respMap.indexOf(id)]);
-    newState = [...newState, ...inserts];
+/**
+ * Handles mapList operations (insert, replace, delete, shift, sort, unshift)
+ * mapList is a hybrid: { [mapKeyValue]: ModelObj[] }
+ */
+const handleMapListOperation = (
+  state: MapListState,
+  op: string,
+  payload: any,
+  sort: SortFn | undefined,
+  keyName: string,
+  mapKeyName: string,
+  initialState: any
+): MapListState | undefined => {
+  switch (op) {
+    case "insert":
+      if (payload) return mapListInsertReducer(state, { payload, sort, keyName, mapKeyName });
+      break;
+    case "unshift":
+      if (payload) return mapListUnshiftReducer(state, { payload, sort, keyName, mapKeyName });
+      break;
+    case "replace":
+      return mapListReplaceReducer(state, { payload, sort, keyName, mapKeyName });
+    case "delete":
+      return mapListDeleteReducer(state, { payload, keyName, mapKeyName });
+    case "shift":
+      return mapListShiftReducer(state);
+    case "clear":
+      return initialState;
+    case "sort":
+      return mapListSortReducer(state, { sort, keyName, mapKeyName });
   }
-  if (action?.sort) newState.sort(action?.sort);
-  return newState;
-};
-
-const listSortReducer = (state: ModelObj[], action: ListSortAction) => {
-  if (!state) state = [];
-  let newState = [...state];
-  let sort = action?.sort ? action.sort : keySort(action.keyName);
-  newState.sort(sort);
-  return newState;
+  return undefined;
 };
 
-const listDeleteReducer = (state: ModelObj[], action: ListAction) => {
-  if (!state || !Array.isArray(state)) state = [];
-  let newState = [...state];
-  let resp: ModelObj[] = Array.isArray(action.payload) ? action.payload : [action.payload];
-
-  let stateMap: Id[] = newState.map((s: any) => s[action.keyName]);
-  for (let i in resp) {
-    let index = stateMap.indexOf(resp[i][action.keyName]);
-    if (index >= 0) newState.splice(index, 1);
+/**
+ * Handles map operations (insert, replace, delete, clear)
+ */
+const handleMapOperation = (
+  state: ModelObj,
+  op: string,
+  payload: any,
+  keyName: string,
+  initialState: any
+): ModelObj | null | undefined => {
+  switch (op) {
+    case "insert":
+      if (payload) return mapInsertReducer(state, { payload, keyName });
+      break;
+    case "replace":
+      return mapReplaceReducer(state, { payload, keyName });
+    case "delete":
+      return mapDeleteReducer(state, { payload, keyName });
+    case "clear":
+      return initialState;
   }
-  return newState;
+  return undefined;
 };
 
-const listShiftReducer = (state: ModelObj[]) => {
-  if (!state || !Array.isArray(state)) state = [];
-  let newState = [...state];
-  newState.shift();
-  return newState;
-}
-
-const listReplaceReducer = (state: ModelObj[], action: ListAction) => {
-  let resp: ModelObj[] = Array.isArray(action.payload) ? action.payload : [action.payload];
-  resp = resp.map((r: any) => ({ ...r }));
-  if (action?.sort) resp.sort(action?.sort);
-  return resp;
-};
-
-const objInsertReducer = (state: any, action: { payload: any }) => {
-  return action.payload;
+/**
+ * Handles static/object operations (insert, replace, delete, clear)
+ */
+const handleStaticOperation = (
+  state: any,
+  op: string,
+  payload: any,
+  initialState: any
+): any | undefined => {
+  switch (op) {
+    case "insert":
+      return objInsertReducer(state, { payload });
+    case "replace":
+      return objReplaceReducer(state, { payload });
+    case "delete":
+      return objDeleteReducer();
+    case "clear":
+      return initialState;
+  }
+  return undefined;
 };
 
-const objReplaceReducer = (state: any, action: { payload: any }) => {
-  return action.payload;
-};
+/**
+ * Builds a reducer function for managing state with various operations
+ */
+function reducerBuilder(key: string, opts?: ReducerOpts) {
+  const stateType = opts?.stateType ?? "static";
+  const isList = stateType === "list";
+  const isMap = stateType === "map";
+  const isMapList = stateType === "mapList";
 
-const objDeleteReducer = () => {
-  return null;
-};
+  if (isMapList && !opts?.mapKeyName) {
+    throw new Error("mapKeyName is required for stateType: mapList");
+  }
 
-interface ReducerOpts {
-  stateType?: "list" | "map" | "static" | "mapList";
-  sort?: SortFn;
-  keyName?: string;
-  mapKeyName?: string;
-  initialState?: any;
-}
+  // Use provided initialState if defined, otherwise get default based on state type
+  const initialState = opts?.initialState !== undefined ? opts.initialState : getDefaultInitialState(stateType);
+  const actionPattern = new RegExp(`^${key}/([^\/]+)$`);
 
-const OPS = ["insert", "replace", "delete", "clear", "sort"];
-function reducerBuilder(key: string, opts?: ReducerOpts) {
-  let initialState = opts?.initialState;
-  let stateType = opts?.stateType ?? "static";
-  let isList = stateType === "list";
-  let isMap = stateType === "map";
-  let isMapList = stateType === "mapList";
-
-  if (isMapList && !opts?.mapKeyName) throw new Error("mapKeyName is required for stateType: mapList");
-
-  if (initialState === undefined) {
-    if (isList) initialState = [];
-    else if (isMap) initialState = {};
-    else initialState = null;
-  }
-  return (state: any, action: { type: string; payload?: any; sort?: (a: ModelObj, b: ModelObj) => number }) => {
+  return (state: any, action: ReducerAction): any => {
+    // Initialize state
     if (state === undefined) {
-      if (initialState !== undefined) return initialState;
-      else if (isList) return [];
-      else if (isMap) return {};
-      else if (isMapList) return {};
-      else return null;
+      return initialState !== undefined ? initialState : getDefaultInitialState(stateType);
     }
-    let rx = new RegExp(`^${key}/([^\/]+)$`);
-    let m = action.type.match(rx);
-    if (!m) return state;
 
-    let op = m[1];
+    // Match action type
+    const match = action.type.match(actionPattern);
+    if (!match) return state;
+
+    let op = match[1];
     let payload = action.payload;
-    let keyName = opts?.keyName ?? "id";
-    let mapKeyName = opts?.mapKeyName;
-
-    if (isMap && !OPS.includes(op)) {
-      if (payload && !Array.isArray(payload)) {
-        payload[keyName] = op;
-        op = "insert";
-      }
-      if (!payload) {
-        payload = {};
-        payload[keyName] = op;
-        op = "delete";
-      }
+    const keyName = opts?.keyName ?? "id";
+    const mapKeyName = opts?.mapKeyName;
+    const sort = action.sort ?? opts?.sort;
+
+    // Handle map-specific operation normalization
+    if (isMap) {
+      const normalized = normalizeMapOperation(op, payload, keyName);
+      op = normalized.op;
+      payload = normalized.payload;
     }
 
-    let sort = action.sort ?? opts?.sort;
-    if (op === "insert") {
-
-      if ((isList || isMapList) && payload) return listInsertReducer(state, { payload, sort, keyName, mapKeyName, isMapList });
-      else if (isMap && payload) return mapInsertReducer(state, { payload, keyName });
-      return objInsertReducer(state, { payload });
-      
-    } else if (op === "replace") {
-
-      if (isList || isMapList) return listReplaceReducer(state, { payload, sort, keyName, mapKeyName, isMapList });
-      else if (isMap) return mapReplaceReducer(state, { payload, keyName });
-      return objReplaceReducer(state, { payload });
-
-    } else if (op === "delete") {
-
-      if (isList || isMapList) return listDeleteReducer(state, { payload, keyName, mapKeyName, isMapList });
-      else if (isMap) return mapDeleteReducer(state, { payload, keyName });
-      return objDeleteReducer();
-
-    } else if (op === "shift") {
-      if (isList || isMapList) return listShiftReducer(state);
-      else {
-        console.error(`unshift is only valid for stateType: list or mapList`);
-      }
-
-    } else if (op === "clear") {
-
-      return initialState;
-
-    } else if (op === "sort") {
-
-      if (isList || isMapList) return listSortReducer(state, { sort, keyName, mapKeyName, isMapList });
+    // Handle operations based on state type
+    let result: any;
 
+    if (isList) {
+      result = handleListOperation(state, op, payload, sort, keyName, initialState);
+    } else if (isMapList) {
+      result = handleMapListOperation(state, op, payload, sort, keyName, mapKeyName!, initialState);
+    } else if (isMap) {
+      result = handleMapOperation(state, op, payload, keyName, initialState);
     } else {
+      result = handleStaticOperation(state, op, payload, initialState);
+    }
 
-      console.error(`unknown op (${op}) in action type: ${action.type}. Op should be one of: insert, delete, replace, clear, or sort.`);
+    if (result !== undefined) {
+      return result;
+    }
 
+    // Unknown operation
+    if (!["insert", "unshift", "replace", "delete", "shift", "clear", "sort"].includes(op)) {
+      console.error(
+        `unknown op (${op}) in action type: ${action.type}. Op should be one of: insert, delete, replace, clear, or sort.`
+      );
     }
-    
-    return state || (isList ? [] : isMap ? {} : null);
+
+    return state || getDefaultInitialState(stateType);
   };
 }
 

package/src/listReducers.ts

@@ -0,0 +1,86 @@
+import { ModelObj, Id, ListAction, ListSortAction } from "./types";
+import { normalizePayload, initializeState, keySort } from "./helpers";
+
+/**
+ * Helper to get key mappings from items
+ */
+const getKeyMap = (items: ModelObj[], keyName: string): Id[] => {
+  return items.map((item: ModelObj) => item[keyName]);
+};
+
+/**
+ * Helper to find items to insert (not in state) and items to replace (in state)
+ */
+const partitionItems = (respMap: Id[], stateMap: Id[]) => {
+  const toInsert = respMap.filter((id: Id) => stateMap.indexOf(id) < 0);
+  const toReplace = respMap.filter((id: Id) => stateMap.indexOf(id) >= 0);
+  return { toInsert, toReplace };
+};
+
+export const listInsertReducer = (state: ModelObj[], action: ListAction): ModelObj[] => {
+  const currentState = initializeState(state, []);
+  const items = normalizePayload(action.payload);
+  
+  let newState = [...currentState];
+  const respMap = getKeyMap(items, action.keyName);
+  const stateMap = getKeyMap(newState, action.keyName);
+  const { toInsert, toReplace } = partitionItems(respMap, stateMap);
+  
+  // Update existing items
+  for (const id of toReplace) {
+    const stateIndex = stateMap.indexOf(id);
+    const respIndex = respMap.indexOf(id);
+    newState[stateIndex] = { ...items[respIndex] };
+  }
+  
+  // Add new items
+  if (toInsert.length > 0) {
+    const inserts = toInsert.map((id: Id) => items[respMap.indexOf(id)]);
+    newState = [...newState, ...inserts];
+  }
+  
+  if (action?.sort) {
+    newState.sort(action.sort);
+  }
+  
+  return newState;
+};
+
+export const listUnshiftReducer = (state: ModelObj[], action: ListAction): ModelObj[] => {
+  const currentState = initializeState(state, []);
+  const items = normalizePayload(action.payload);
+  return [...items, ...currentState];
+};
+
+export const listSortReducer = (state: ModelObj[], action: ListSortAction): ModelObj[] => {
+  const currentState = initializeState(state, []);
+  const newState = [...currentState];
+  const sort = action?.sort ?? keySort(action.keyName);
+  newState.sort(sort);
+  return newState;
+};
+
+export const listDeleteReducer = (state: ModelObj[], action: ListAction): ModelObj[] => {
+  const currentState = !state || !Array.isArray(state) ? [] : state;
+  const items = normalizePayload(action.payload);
+  const deleteKeys = new Set<Id>(getKeyMap(items, action.keyName));
+  return currentState.filter((item: ModelObj) => !deleteKeys.has(item[action.keyName]));
+};
+
+export const listShiftReducer = (state: ModelObj[]): ModelObj[] => {
+  const currentState = !state || !Array.isArray(state) ? [] : state;
+  const newState = [...currentState];
+  newState.shift();
+  return newState;
+};
+
+export const listReplaceReducer = (state: ModelObj[], action: ListAction): ModelObj[] => {
+  const items = normalizePayload(action.payload);
+  const result = items.map((item: ModelObj) => ({ ...item }));
+  
+  if (action?.sort) {
+    result.sort(action.sort);
+  }
+  
+  return result;
+};