carriera-intern 0.0.0

package/projects/carriera-intern-components/src/app/components/input/utilities/helpers/input.helper.ts

@@ -0,0 +1,985 @@
+import {
+  Bank,
+  Broker,
+  ColorOption,
+  Contact,
+  DepartmentContactsPair,
+  Dispatch,
+  DispatchBoard,
+  Dispatcher,
+  DropdownOption,
+  Franchise,
+  FuelCard,
+  FuelStopStore,
+  Hazardous,
+  MakeOption,
+  Owner,
+  PMOption,
+  Provider,
+  Shipper,
+  SplitDriverBoard,
+  SplitTrailerBoard,
+  SplitTruckBoard,
+  State,
+  TollOption,
+  TrailerType,
+  TruckType,
+  CaiInputConfig,
+  DropdownArrays,
+  DropdownOptions,
+} from '../../models';
+
+import { CastableType, CastableTypeMap } from '../constants/cast.constants';
+
+export class InputHelper {
+  static hasProperty<T extends object>(
+    obj: T,
+    prop: PropertyKey,
+  ): prop is keyof T {
+    return prop in obj;
+  }
+
+  static getOptionValue(
+    value: string,
+    options: DropdownOptions[],
+    optionValue: keyof DropdownOptions,
+    config: CaiInputConfig,
+  ): {
+    newValue?: string;
+    selectedOption?: DropdownOptions;
+    multipleSelectedOptions?: DropdownOptions[];
+  } {
+    let newValue;
+    let selectedOption;
+    let multipleSelectedOptions;
+
+    switch (config.dropdown) {
+      case 'dispatch':
+      case 'ftl-dispatch':
+        // TODO: Leave only board variant once backend is fixed
+        if (this.hasProperty(options[0], 'dispatches')) {
+          for (const board of (options as DispatchBoard[])!) {
+            const dispatch = board.dispatches.find((dispatch) => {
+              if (optionValue && this.hasProperty(dispatch, optionValue)) {
+                return dispatch[optionValue]?.toString() === value?.toString();
+              } else {
+                return dispatch.id?.toString() === value?.toString();
+              }
+            });
+            if (dispatch) {
+              selectedOption = dispatch;
+            }
+            newValue = '';
+          }
+        } else {
+          const dispatch = (options as Dispatch[])!.find((dispatch) => {
+            if (optionValue && this.hasProperty(dispatch, optionValue)) {
+              return dispatch[optionValue]?.toString() === value?.toString();
+            } else {
+              return dispatch.id?.toString() === value?.toString();
+            }
+          });
+          if (dispatch) {
+            selectedOption = dispatch;
+          }
+          newValue = '';
+        }
+        break;
+      case 'broker':
+        const broker = (options as Broker[])!.find((broker) => {
+          if (optionValue && this.hasProperty(broker, optionValue)) {
+            return broker[optionValue]?.toString() === value?.toString();
+          } else {
+            return broker.id?.toString() === value?.toString();
+          }
+        });
+        if (broker) {
+          selectedOption = broker;
+        }
+        newValue = '';
+        break;
+      case 'contact':
+        for (const departmentContactsPair of options as DepartmentContactsPair[]) {
+          const contact = departmentContactsPair.contacts?.find((contact) => {
+            if (optionValue && this.hasProperty(contact, optionValue)) {
+              return contact[optionValue]?.toString() === value?.toString();
+            } else {
+              return contact.id?.toString() === value?.toString();
+            }
+          });
+          if (contact) {
+            selectedOption = contact;
+          }
+          newValue = '';
+        }
+        break;
+      case 'shipper':
+        const shipper = (options as Shipper[])!.find((shipper) => {
+          if (optionValue && this.hasProperty(shipper, optionValue)) {
+            return shipper[optionValue]?.toString() === value?.toString();
+          } else {
+            return shipper.id?.toString() === value?.toString();
+          }
+        });
+        if (shipper) {
+          selectedOption = shipper;
+        }
+        newValue = '';
+        break;
+      case 'bank':
+        const bank = (options as Bank[])!.find((bank) => {
+          if (optionValue && this.hasProperty(bank, optionValue)) {
+            return bank[optionValue]?.toString() === value?.toString();
+          } else {
+            return bank.id?.toString() === value?.toString();
+          }
+        });
+        if (bank) {
+          selectedOption = bank;
+        }
+        newValue = '';
+        break;
+      case 'provider':
+        const provider = (options as Provider[])!.find((provider) => {
+          if (optionValue && this.hasProperty(provider, optionValue)) {
+            return provider[optionValue]?.toString() === value?.toString();
+          } else {
+            return provider.id?.toString() === value?.toString();
+          }
+        });
+        if (provider) {
+          selectedOption = provider;
+        }
+        newValue = '';
+
+        break;
+      case 'dispatcher':
+        const dispatcher = (options as Dispatcher[])!.find((dispatcher) => {
+          if (optionValue && this.hasProperty(dispatcher, optionValue)) {
+            return dispatcher[optionValue]?.toString() === value?.toString();
+          } else {
+            return dispatcher.id?.toString() === value?.toString();
+          }
+        });
+        if (dispatcher) {
+          selectedOption = dispatcher;
+        }
+        newValue = '';
+        break;
+      case 'truck':
+        const truck = (options as TruckType[])!.find((truck) => {
+          if (optionValue && this.hasProperty(truck, optionValue)) {
+            return truck[optionValue]?.toString() === value?.toString();
+          } else {
+            return truck.id?.toString() === value?.toString();
+          }
+        });
+        if (truck) {
+          selectedOption = truck;
+        }
+        newValue = '';
+        break;
+      case 'trailer':
+        const trailer = (options as TrailerType[])!.find((trailer) => {
+          if (optionValue && this.hasProperty(trailer, optionValue)) {
+            return trailer[optionValue]?.toString() === value?.toString();
+          } else {
+            return trailer.id?.toString() === value?.toString();
+          }
+        });
+        if (trailer) {
+          selectedOption = trailer;
+        }
+        newValue = '';
+        break;
+      case 'hazardous':
+        const hazardous = (options as Hazardous[])!.find((hazardous) => {
+          if (optionValue && this.hasProperty(hazardous, optionValue)) {
+            return hazardous[optionValue]?.toString() === value?.toString();
+          } else {
+            return hazardous.id?.toString() === value?.toString();
+          }
+        });
+        if (hazardous) {
+          selectedOption = hazardous;
+        }
+        newValue = '';
+        break;
+      case 'owner':
+        const owner = (options as Owner[])!.find((owner) => {
+          if (optionValue && this.hasProperty(owner, optionValue)) {
+            return owner[optionValue]?.toString() === value?.toString();
+          } else {
+            return owner.id?.toString() === value?.toString();
+          }
+        });
+        if (owner) {
+          selectedOption = owner;
+        }
+        newValue = '';
+        break;
+      case 'state':
+        const state = (options as State[])!.find((state) => {
+          if (optionValue && this.hasProperty(state, optionValue)) {
+            return state[optionValue]?.toString() === value?.toString();
+          } else {
+            return state.id?.toString() === value?.toString();
+          }
+        });
+        if (state) {
+          selectedOption = state;
+        }
+        newValue = '';
+        break;
+      case 'fuelcard':
+        const fuelcard = (options as FuelCard[])!.find((fuelcard) => {
+          if (optionValue && this.hasProperty(fuelcard, optionValue)) {
+            return fuelcard[optionValue]?.toString() === value?.toString();
+          } else {
+            return fuelcard.id?.toString() === value?.toString();
+          }
+        });
+        if (fuelcard) {
+          selectedOption = fuelcard;
+        }
+        newValue = '';
+        break;
+      case 'multiple':
+        const multipleOptions = (options as DropdownOption[])!.filter(
+          (option) => {
+            if (optionValue && this.hasProperty(option, optionValue)) {
+              return value.includes(option[optionValue]?.toString() || '');
+            } else {
+              return value.includes(option.id?.toString() || '');
+            }
+          },
+        );
+
+        if (!!multipleOptions.length) {
+          multipleSelectedOptions = multipleOptions;
+        }
+        newValue = '';
+
+        break;
+      case 'pm':
+        const pm = (options as PMOption[])!.find((pm) => {
+          if (optionValue && this.hasProperty(pm, optionValue)) {
+            return pm[optionValue]?.toString() === value?.toString();
+          } else {
+            return pm.id?.toString() === value?.toString();
+          }
+        });
+        if (pm) {
+          selectedOption = pm;
+        }
+        newValue = '';
+        break;
+      case 'make':
+        const make = (options as MakeOption[])!.find((make) => {
+          if (optionValue && this.hasProperty(make, optionValue)) {
+            return make[optionValue]?.toString() === value?.toString();
+          } else {
+            return make.id?.toString() === value?.toString();
+          }
+        });
+        if (make) {
+          selectedOption = make;
+        }
+        newValue = '';
+        break;
+      case 'toll':
+        (options as TollOption[]).forEach((toll) => {
+          const transponder = toll.tollTransponders?.find((transponder) => {
+            if (optionValue && this.hasProperty(transponder, optionValue)) {
+              return transponder[optionValue]?.toString() === value?.toString();
+            } else {
+              return transponder.id?.toString() === value?.toString();
+            }
+          });
+          if (transponder) {
+            selectedOption = transponder;
+          }
+          newValue = '';
+        });
+
+        break;
+      case 'color':
+        const color = (options as ColorOption[])!.find((color) => {
+          if (optionValue && this.hasProperty(color, optionValue)) {
+            return color[optionValue]?.toString() === value?.toString();
+          } else {
+            return color.id?.toString() === value?.toString();
+          }
+        });
+        if (color) {
+          selectedOption = color;
+        }
+        newValue = '';
+        break;
+      case 'split-driver':
+        for (const board of options as SplitDriverBoard[]) {
+          const driver = board.drivers?.find((driver) => {
+            if (optionValue && this.hasProperty(driver, optionValue)) {
+              return driver[optionValue]?.toString() === value?.toString();
+            } else {
+              return driver.id?.toString() === value?.toString();
+            }
+          });
+          if (driver) {
+            selectedOption = driver;
+          }
+          newValue = '';
+        }
+        break;
+      case 'split-truck':
+        for (const board of options as SplitTruckBoard[]) {
+          const truck = board.trucks?.find((truck) => {
+            if (optionValue && this.hasProperty(truck, optionValue)) {
+              return truck[optionValue]?.toString() === value?.toString();
+            } else {
+              return truck.id?.toString() === value?.toString();
+            }
+          });
+          if (truck) {
+            selectedOption = truck;
+          }
+          newValue = '';
+        }
+        break;
+      case 'split-trailer':
+        for (const board of options as SplitTrailerBoard[]) {
+          const trailer = board.trailers?.find((trailer) => {
+            if (optionValue && this.hasProperty(trailer, optionValue)) {
+              return trailer[optionValue]?.toString() === value?.toString();
+            } else {
+              return trailer.id?.toString() === value?.toString();
+            }
+          });
+          if (trailer) {
+            selectedOption = trailer;
+          }
+          newValue = '';
+        }
+        break;
+      case 'subcontent':
+        break;
+      case true:
+        const option = (options as DropdownOption[])!.find((option) => {
+          if (optionValue && this.hasProperty(option, optionValue)) {
+            return option[optionValue]?.toString() === value?.toString();
+          } else {
+            return option.id?.toString() === value?.toString();
+          }
+        });
+        if (option) {
+          if (!config.dropdownAutocomplete) {
+            selectedOption = option;
+          }
+          if ((config.search && !config.dropdownAutocomplete) || config.add) {
+            newValue = '';
+          } else {
+            newValue = option[config.optionLabel || 'label']?.toString() || '';
+          }
+        } else {
+          newValue = '';
+        }
+        break;
+      default:
+        break;
+    }
+
+    return {
+      newValue,
+      selectedOption,
+      multipleSelectedOptions,
+    };
+  }
+
+  // Type-safe casting for templates
+  static cast<T extends CastableType>(
+    value: unknown,
+    type: T,
+  ): CastableTypeMap[T] | null {
+    return value as CastableTypeMap[T];
+  }
+
+  static getSearchedDropdownOptions(
+    options: DropdownArrays,
+    value: string | undefined | null,
+    type: CaiInputConfig['dropdown'],
+    shouldSearch?: boolean,
+    foldedBoards?: number[],
+    label?: string,
+    openGroup?: number | null,
+    isOpen?: boolean,
+  ): any[] {
+    if (!isOpen) {
+      return [];
+    }
+
+    const optionLabel = label || 'label';
+
+    if (!Array.isArray(options)) {
+      return [];
+    }
+
+    if (!options.length) {
+      return [];
+    }
+
+    if (typeof value !== 'string') {
+      // For fuel-stop-transaction, we still need to process openGroup logic even without search
+      if (type === 'fuel-stop-transaction') {
+        let franchises = (options as Franchise[]) || [];
+
+        // Process each franchise based on openGroup, even without search
+        franchises = franchises.map((franchise) => {
+          const isOpen = openGroup === franchise.id;
+
+          if (!isOpen) {
+            // Franchise is closed - show franchise but no stores
+            return {
+              ...franchise,
+              fuelStopStores: [],
+            };
+          }
+
+          // Franchise is open - show franchise with stores
+          return franchise;
+        });
+
+        return franchises as Franchise[];
+      }
+
+      return options;
+    }
+
+    const searchValue = value?.trim().toLowerCase();
+
+    switch (type) {
+      case 'dispatch':
+      case 'ftl-dispatch':
+        if (!(options as DispatchBoard[]) || !(options as Dispatch[]))
+          return [];
+
+        // TODO: Leave only board variant once backend is fixed
+        let dispatches = (options as DispatchBoard[]) || [];
+
+        if (!this.hasProperty(dispatches[0], 'dispatches')) {
+          dispatches = [
+            {
+              dispatcher: 'NOBOARDSVARIANT',
+              count: options.length,
+              id: 0,
+              dispatches: options as Dispatch[],
+              teamBoard: false,
+            },
+          ];
+        }
+
+        if (!shouldSearch) {
+          return dispatches as DispatchBoard[];
+        }
+
+        if (searchValue) {
+          dispatches = dispatches.map((board) => {
+            const newBoard = { ...board };
+
+            newBoard.dispatches = board.dispatches.filter((dispatch) => {
+              const truckIdMatch = dispatch.truck.truckNumber
+                ?.toString()
+                .toLowerCase()
+                .includes(searchValue);
+              const trailerIdMatch = dispatch.trailer?.trailerNumber
+                ?.toString()
+                .toLowerCase()
+                .includes(searchValue);
+
+              let driverNameMatch = (
+                dispatch.driver?.firstName?.toLowerCase() +
+                ' ' +
+                dispatch.driver?.lastName?.toLowerCase()
+              ).includes(searchValue);
+
+              if (dispatch.coDriver) {
+                driverNameMatch = (
+                  dispatch.driver.firstName.toLowerCase() +
+                  ' & ' +
+                  dispatch.coDriver.firstName.toLowerCase()
+                ).includes(searchValue);
+              }
+
+              return truckIdMatch || trailerIdMatch || driverNameMatch;
+            });
+
+            return newBoard;
+          });
+        }
+
+        if (foldedBoards?.length && !searchValue) {
+          dispatches = dispatches.map((board) => {
+            if (foldedBoards.includes(board.id)) {
+              const { dispatches, ...rest } = board;
+
+              return rest as DispatchBoard;
+            }
+            return board;
+          });
+        }
+
+        return dispatches as DispatchBoard[];
+      case 'broker':
+        const brokers = (options as Broker[]) || [];
+
+        if (!shouldSearch) {
+          return brokers as Broker[];
+        }
+
+        if (searchValue) {
+          return brokers.filter((broker) =>
+            (broker.businessName || '').toLowerCase().includes(searchValue),
+          );
+        }
+        return brokers;
+      case 'contact':
+        const contacts =
+          (options as DepartmentContactsPair[])
+            .sort((a, b) => (a.department?.id || 0) - (b.department?.id || 0))
+            .flatMap((pair) =>
+              (pair.contacts || []).map((contact) => ({
+                ...contact,
+                department: pair.department,
+              })),
+            ) || [];
+
+        if (!shouldSearch) {
+          return contacts;
+        }
+
+        if (searchValue) {
+          return contacts?.filter((contact) =>
+            (contact?.contactName || '').toLowerCase().includes(searchValue),
+          );
+        }
+        return contacts;
+      case 'shipper':
+        const shippers = (options as Shipper[]) || [];
+
+        if (!shouldSearch) {
+          return shippers;
+        }
+
+        if (searchValue) {
+          return shippers.filter((shipper) =>
+            (shipper.businessName + ' ' + shipper.address?.address || '')
+              .toLowerCase()
+              .includes(searchValue),
+          );
+        }
+        return shippers;
+      case 'bank':
+        const banks = (options as Bank[]) || [];
+
+        if (!shouldSearch) {
+          return banks;
+        }
+
+        if (searchValue) {
+          return banks.filter((bank) =>
+            bank.name?.toLowerCase().includes(searchValue),
+          );
+        }
+        return banks;
+      case 'dispatcher':
+        const dispatcher = (options as Dispatcher[]) || [];
+
+        if (!shouldSearch) {
+          return dispatcher;
+        }
+
+        if (searchValue) {
+          return dispatcher.filter((bank) =>
+            bank.fullName?.toLowerCase().includes(searchValue),
+          );
+        }
+        return dispatcher;
+      case 'truck':
+        const trucks = (options as TruckType[]) || [];
+
+        if (!shouldSearch) {
+          return trucks;
+        }
+
+        if (searchValue) {
+          return trucks.filter((truck) =>
+            (truck.name || '').toLowerCase().includes(searchValue),
+          );
+        }
+        return trucks;
+      case 'trailer':
+        const trailers = (options as TrailerType[]) || [];
+
+        if (!shouldSearch) {
+          return trailers;
+        }
+
+        if (searchValue) {
+          return trailers.filter((trailer) =>
+            (trailer.name || '').toLowerCase().includes(searchValue),
+          );
+        }
+        return trailers;
+      case 'hazardous':
+        const hazardous = (options as Hazardous[]) || [];
+
+        if (!shouldSearch) {
+          return hazardous;
+        }
+
+        if (searchValue) {
+          return hazardous.filter((hazardous) =>
+            hazardous.description?.toLowerCase().includes(searchValue),
+          );
+        }
+        return hazardous;
+      case 'state':
+        const states = (options as State[]) || [];
+
+        if (!shouldSearch) {
+          return states;
+        }
+
+        if (searchValue) {
+          return states.filter((state) =>
+            (state?.stateShortName + ' ' + state?.stateName)
+              ?.toLowerCase()
+              .includes(searchValue),
+          );
+        }
+        return states;
+      case 'owner':
+        const owners = (options as Owner[]) || [];
+
+        if (!shouldSearch) {
+          return owners;
+        }
+
+        if (searchValue) {
+          return owners.filter((owner) =>
+            (owner.ein?.toLowerCase() || '')
+              .concat(' ', owner.name?.toLowerCase() || '')
+              .includes(searchValue),
+          );
+        }
+        return owners;
+      case 'fuelcard':
+        const fuelcards = (options as FuelCard[]) || [];
+
+        if (!shouldSearch) {
+          return fuelcards;
+        }
+
+        if (searchValue) {
+          return fuelcards.filter((fuelcard) =>
+            (fuelcard.number?.toLowerCase() || '')
+              .concat(' ', fuelcard.brand?.toLowerCase() || '')
+              .concat(' ', fuelcard.account?.toLowerCase() || '')
+              .includes(searchValue),
+          );
+        }
+        return fuelcards;
+      case 'color':
+        const colors = (options as ColorOption[]) || [];
+
+        if (!shouldSearch) {
+          return colors;
+        }
+
+        if (searchValue) {
+          return colors.filter((color) =>
+            color.name?.toLowerCase().includes(searchValue),
+          );
+        }
+        return colors;
+      case 'make':
+        const makes = (options as MakeOption[]) || [];
+
+        if (!shouldSearch) {
+          return makes;
+        }
+
+        if (searchValue) {
+          return makes.filter((make) =>
+            make.name?.toLowerCase().includes(searchValue),
+          );
+        }
+        return makes;
+      case 'toll':
+        const tolls = (options as TollOption[]) || [];
+
+        if (!shouldSearch) {
+          return tolls;
+        }
+
+        if (searchValue) {
+          return tolls.map((toll) => {
+            return {
+              ...toll,
+              tollTransponders: toll.tollTransponders?.filter((transponder) =>
+                transponder.name?.toLowerCase().includes(searchValue),
+              ),
+            };
+          });
+        }
+        return tolls;
+      case 'fuel-stop-transaction':
+        if (!(options as Franchise[]) || !(options as FuelStopStore[]))
+          return [];
+
+        let franchises = (options as Franchise[]) || [];
+
+        if (!shouldSearch) {
+          return franchises as Franchise[];
+        }
+
+        // Process each franchise: if it's the open one, show stores; if closed, hide stores
+        franchises = franchises.map((franchise) => {
+          const isOpen = openGroup === franchise.id;
+
+          if (!isOpen) {
+            // Franchise is closed - show franchise but no stores
+            const { fuelStopStores, ...rest } = franchise;
+            return rest as Franchise;
+          }
+
+          // Franchise is open - show franchise with stores
+          const newFranchise = { ...franchise };
+
+          // If searching and this is the open franchise, filter the stores
+          if (searchValue) {
+            newFranchise.fuelStopStores = franchise.fuelStopStores?.filter(
+              (fuelStopStore) => {
+                const storeMatch = fuelStopStore.store
+                  ?.toString()
+                  .toLowerCase()
+                  .includes(searchValue);
+
+                const city = fuelStopStore.address?.city ?? '';
+                const state = fuelStopStore.address?.stateShortName ?? '';
+                const zip = fuelStopStore.address?.zipCode ?? '';
+
+                const businessNameMatch = franchise?.businessName
+                  ?.toString()
+                  .toLowerCase()
+                  .includes(searchValue);
+
+                const cityStateZipMatch = (
+                  city +
+                  (state || zip ? ', ' : '') +
+                  state +
+                  ' ' +
+                  zip
+                )
+                  ?.toLowerCase()
+                  .trim()
+                  .includes(searchValue);
+
+                return storeMatch || cityStateZipMatch || businessNameMatch;
+              },
+            );
+          }
+
+          return newFranchise;
+        });
+
+        // If searching, filter closed franchises by businessName but always keep the open one
+        if (searchValue) {
+          franchises = franchises?.filter((franchise) => {
+            const isOpen = openGroup === franchise?.id;
+            // Always show open franchise, filter closed ones by businessName
+            return (
+              isOpen ||
+              franchise?.businessName?.toLowerCase().includes(searchValue)
+            );
+          });
+        }
+
+        return franchises as Franchise[];
+      case 'split-driver':
+        if (
+          !(options as SplitDriverBoard[]) ||
+          !(options as SplitDriverBoard[])
+        )
+          return [];
+
+        let splitDriverBoards = (options as SplitDriverBoard[]) || [];
+
+        if (!shouldSearch) {
+          if (foldedBoards?.length && !searchValue) {
+            splitDriverBoards = splitDriverBoards.map((board) => {
+              if (foldedBoards.includes(board.id)) {
+                const { drivers, ...rest } = board;
+
+                return rest as SplitDriverBoard;
+              }
+              return board;
+            });
+          }
+
+          return splitDriverBoards as SplitDriverBoard[];
+        }
+
+        if (searchValue) {
+          splitDriverBoards = splitDriverBoards.map((board) => {
+            const newBoard = { ...board };
+
+            newBoard.drivers =
+              board.drivers?.filter((driver) => {
+                const driverNameMatch = (
+                  driver.firstName?.toLowerCase() +
+                  ' ' +
+                  driver.lastName?.toLowerCase()
+                ).includes(searchValue);
+
+                return driverNameMatch;
+              }) ?? [];
+
+            return newBoard;
+          });
+        }
+
+        if (foldedBoards?.length && !searchValue) {
+          splitDriverBoards = splitDriverBoards.map((board) => {
+            if (foldedBoards.includes(board.id)) {
+              const { drivers, ...rest } = board;
+
+              return rest as SplitDriverBoard;
+            }
+            return board;
+          });
+        }
+
+        return splitDriverBoards as SplitDriverBoard[];
+      case 'split-truck':
+        if (
+          !(options as SplitDriverBoard[]) ||
+          !(options as SplitDriverBoard[])
+        )
+          return [];
+
+        let splitTruckBoards = (options as SplitTruckBoard[]) || [];
+
+        if (!shouldSearch) {
+          if (foldedBoards?.length && !searchValue) {
+            splitTruckBoards = splitTruckBoards.map((board) => {
+              if (foldedBoards.includes(board.id)) {
+                const { trucks, ...rest } = board;
+
+                return rest as SplitTruckBoard;
+              }
+              return board;
+            });
+          }
+
+          return splitTruckBoards as SplitTruckBoard[];
+        }
+
+        if (searchValue) {
+          splitTruckBoards = splitTruckBoards.map((board) => {
+            const newBoard = { ...board };
+
+            newBoard.trucks =
+              board.trucks?.filter((truck) => {
+                const truckNumberMatch = truck.truckNumber
+                  ?.toLowerCase()
+                  .includes(searchValue);
+
+                return truckNumberMatch;
+              }) ?? [];
+
+            return newBoard;
+          });
+        }
+
+        if (foldedBoards?.length && !searchValue) {
+          splitTruckBoards = splitTruckBoards.map((board) => {
+            if (foldedBoards.includes(board.id)) {
+              const { trucks, ...rest } = board;
+
+              return rest as SplitTruckBoard;
+            }
+            return board;
+          });
+        }
+
+        return splitTruckBoards as SplitTruckBoard[];
+      case 'split-trailer':
+        if (
+          !(options as SplitDriverBoard[]) ||
+          !(options as SplitDriverBoard[])
+        )
+          return [];
+
+        let splitTrailerBoards = (options as SplitTrailerBoard[]) || [];
+
+        if (!shouldSearch) {
+          if (foldedBoards?.length && !searchValue) {
+            splitTrailerBoards = splitTrailerBoards.map((board) => {
+              if (foldedBoards.includes(board.id)) {
+                const { trailers, ...rest } = board;
+
+                return rest as SplitTrailerBoard;
+              }
+              return board;
+            });
+          }
+
+          return splitTrailerBoards as SplitTrailerBoard[];
+        }
+
+        if (searchValue) {
+          splitTrailerBoards = splitTrailerBoards.map((board) => {
+            const newBoard = { ...board };
+
+            newBoard.trailers =
+              board?.trailers?.filter((trailer) => {
+                const trailerNumberMatch = trailer.trailerNumber
+                  ?.toLowerCase()
+                  .includes(searchValue);
+
+                return trailerNumberMatch;
+              }) ?? [];
+
+            return newBoard;
+          });
+        }
+
+        if (foldedBoards?.length && !searchValue) {
+          splitTrailerBoards = splitTrailerBoards.map((board) => {
+            if (foldedBoards.includes(board.id)) {
+              const { trailers, ...rest } = board;
+
+              return rest as SplitTrailerBoard;
+            }
+            return board;
+          });
+        }
+
+        return splitTrailerBoards as SplitTrailerBoard[];
+      default:
+        const dropdownOptions = options as any[];
+
+        if (!shouldSearch) {
+          return options;
+        }
+
+        if (searchValue) {
+          return dropdownOptions?.filter((option) =>
+            option[optionLabel]?.toLowerCase().includes(searchValue),
+          );
+        }
+
+        return options;
+    }
+  }
+}