refactor: Unify generator store slices creation

src/hooks/useGeneratorStore/slices/index.ts

@@ -1,2 +1,3 @@
-export * from './loadProfile'
 export * from './rules'
+export * from './testData'
+export * from './testOptions'

src/hooks/useGeneratorStore/slices/recording.ts

@@ -0,0 +1,58 @@
+import { ProxyData } from '@/types'
+import { ImmerStateCreator } from '@/utils/typescript'
+
+interface State {
+  requests: ProxyData[]
+  recordingPath: string
+  allowList: string[]
+  filteredRequests: ProxyData[]
+  showAllowListDialog: boolean
+}
+
+interface Actions {
+  setRecording: (recording: ProxyData[], path: string) => void
+  resetRecording: () => void
+  setAllowList: (value: string[]) => void
+  setFilteredRequests: (requests: ProxyData[]) => void
+  setShowAllowListDialog: (value: boolean) => void
+}
+
+export type RecordingSliceStore = State & Actions
+
+export const createRecordingSlice: ImmerStateCreator<RecordingSliceStore> = (
+  set
+) => ({
+  requests: [],
+  recordingPath: '',
+  allowList: [],
+  filteredRequests: [],
+  showAllowListDialog: false,
+
+  setRecording: (requests: ProxyData[], path: string) =>
+    set((state) => {
+      state.requests = requests
+      state.allowList = []
+      state.filteredRequests = []
+      state.recordingPath = path
+      state.showAllowListDialog = true
+    }),
+  resetRecording: () =>
+    set((state) => {
+      state.requests = []
+      state.allowList = []
+      state.filteredRequests = []
+      state.recordingPath = ''
+    }),
+  setAllowList: (value) =>
+    set((state) => {
+      state.allowList = value
+    }),
+  setFilteredRequests: (requests) =>
+    set((state) => {
+      state.filteredRequests = requests
+    }),
+  setShowAllowListDialog: (value) =>
+    set((state) => {
+      state.showAllowListDialog = value
+    }),
+})

src/hooks/useGeneratorStore/slices/rules.ts

@@ -1,9 +1,23 @@
 import { TestRule } from '@/types/rules'
 import { ImmerStateCreator } from '@/utils/typescript'
 import { rules } from '../fixtures'
-import { RulesState } from '../types'
 
-export const createRulesSlice: ImmerStateCreator<RulesState> = (set) => ({
+interface State {
+  rules: TestRule[]
+  selectedRuleId: string | null
+}
+
+interface Actions {
+  createRule: (type: TestRule['type']) => void
+  updateRule: (rule: TestRule) => void
+  cloneRule: (id: string) => void
+  deleteRule: (id: string) => void
+  selectRule: (id: string) => void
+}
+
+export type RulesSliceStore = State & Actions
+
+export const createRulesSlice: ImmerStateCreator<RulesSliceStore> = (set) => ({
   rules,
   selectedRuleId: null,
   createRule: (type: TestRule['type']) =>

src/hooks/useGeneratorStore/slices/testData.ts

@@ -0,0 +1,21 @@
+import { ImmerStateCreator } from '@/utils/typescript'
+import { Variable } from '@/types'
+
+interface State {
+  variables: Variable[]
+}
+
+interface Actions {
+  setVariables: (variables: Variable[]) => void
+}
+
+export type TestDataStore = State & Actions
+
+export const createTestDataSlice: ImmerStateCreator<TestDataStore> = (set) => ({
+  variables: [],
+
+  setVariables: (variables: Variable[]) =>
+    set((state) => {
+      state.variables = variables
+    }),
+})

src/hooks/useGeneratorStore/slices/testOptions/index.ts

@@ -0,0 +1,12 @@
+import { ImmerStateCreator } from '@/utils/typescript'
+import { LoadProfileStore, createLoadProfileSlice } from './loadProfile'
+import { ThinkTimeStore, createThinkTimeSlice } from './thinkTime'
+
+export type TestOptionsStore = LoadProfileStore & ThinkTimeStore
+
+export const createTestOptionsSlice: ImmerStateCreator<
+  LoadProfileStore & ThinkTimeStore
+> = (...args) => ({
+  ...createLoadProfileSlice(...args),
+  ...createThinkTimeSlice(...args),
+})

src/hooks/useGeneratorStore/slices/testOptions/loadProfile.ts

@@ -0,0 +1,133 @@
+import { ExecutorType } from '@/constants/generator'
+import {
+  RampingStage,
+  RampingVUsOptions,
+  SharedIterationsOptions,
+} from '@/types/testOptions'
+import { ImmerStateCreator } from '@/utils/typescript'
+
+interface SharedIterationsState
+  extends Omit<SharedIterationsOptions, 'executor'> {
+  setVus: (value: SharedIterationsOptions['vus']) => void
+  setIterations: (value: SharedIterationsOptions['iterations']) => void
+  setMaxDuration: (value: SharedIterationsOptions['maxDuration']) => void
+}
+
+interface CommonState {
+  executor: ExecutorType
+  gracefulStop: string | undefined
+  startTime: string | undefined
+}
+
+interface CommonActions {
+  setExecutor: (value: ExecutorType) => void
+  setGracefulStop: (value: string | undefined) => void
+  setStartTime: (value: string | undefined) => void
+}
+
+type CommonStore = CommonState & CommonActions
+
+const createCommonSlice: ImmerStateCreator<CommonStore> = (set) => ({
+  executor: ExecutorType.RampingVUs,
+  gracefulStop: undefined,
+  startTime: undefined,
+
+  setExecutor: (value) =>
+    set((state) => {
+      state.executor = value
+    }),
+  setGracefulStop: (value) =>
+    set((state) => {
+      state.gracefulStop = value
+    }),
+  setStartTime: (value) =>
+    set((state) => {
+      state.startTime = value
+    }),
+})
+
+interface RampingActions {
+  addStage: () => void
+  removeStage: (index: number) => void
+  updateStage: (index: number, value: RampingStage) => void
+  setGracefulRampDown: (value: RampingVUsOptions['gracefulRampDown']) => void
+  setStartVUs: (value: RampingVUsOptions['startVUs']) => void
+}
+
+type RampingStore = Omit<RampingVUsOptions, 'executor'> & RampingActions
+
+const createRampingSlice: ImmerStateCreator<RampingStore> = (set) => ({
+  gracefulRampDown: undefined,
+  stages: [],
+  startVUs: undefined,
+
+  setGracefulRampDown: (value) =>
+    set((state) => {
+      state.gracefulRampDown = value
+    }),
+  addStage: () =>
+    set((state) => {
+      state.stages.push(createStage())
+    }),
+  removeStage: (index) =>
+    set((state) => {
+      state.stages.splice(index, 1)
+    }),
+  updateStage: (index, value) =>
+    set((state) => {
+      state.stages[index] = value
+    }),
+  setStartVUs: (value) =>
+    set((state) => {
+      state.startVUs = value
+    }),
+})
+
+interface SharedIterationsActions {
+  setIterations: (value: number | undefined) => void
+  setMaxDuration: (value: string | undefined) => void
+  setVus: (value: number | undefined) => void
+}
+
+type SharedIterationsStore = Omit<SharedIterationsState, 'executor'> &
+  SharedIterationsActions
+
+const createSharedIterationsSlice: ImmerStateCreator<SharedIterationsStore> = (
+  set
+) => ({
+  iterations: undefined,
+  maxDuration: undefined,
+  vus: undefined,
+
+  setIterations: (value) =>
+    set((state) => {
+      state.iterations = value
+    }),
+  setMaxDuration: (value) =>
+    set((state) => {
+      state.maxDuration = value
+    }),
+  setVus: (value) =>
+    set((state) => {
+      state.vus = value
+    }),
+})
+
+export type LoadProfileStore = CommonStore &
+  RampingStore &
+  SharedIterationsStore
+
+export const createLoadProfileSlice: ImmerStateCreator<LoadProfileStore> = (
+  ...args
+) => ({
+  ...createCommonSlice(...args),
+  ...createRampingSlice(...args),
+  ...createSharedIterationsSlice(...args),
+})
+
+function createStage() {
+  return {
+    target: '',
+    duration: '',
+  }
+}

src/hooks/useGeneratorStore/slices/testOptions/thinkTime.ts

@@ -0,0 +1,32 @@
+import { ImmerStateCreator } from '@/utils/typescript'
+import { SleepType, Timing } from '@/types/testOptions'
+import { createFixedTiming } from '@/utils/thinkTime'
+
+interface State {
+  sleepType: SleepType
+  timing: Timing
+}
+
+interface Actions {
+  setSleepType: (value: SleepType) => void
+  setTiming: (timing: Timing) => void
+}
+
+export type ThinkTimeStore = State & Actions
+
+export const createThinkTimeSlice: ImmerStateCreator<ThinkTimeStore> = (
+  set
+) => ({
+  sleepType: 'groups',
+  timing: createFixedTiming(),
+
+  setSleepType: (value: SleepType) =>
+    set((state) => {
+      state.sleepType = value
+    }),
+
+  setTiming: (timing: Timing) =>
+    set((state) => {
+      state.timing = timing
+    }),
+})