96 lines
2.3 KiB
TypeScript
96 lines
2.3 KiB
TypeScript
import { Feature } from '@/modules/feature/feature'
|
|
import { initBoard, newBoard, nextDay } from '@/modules/feature/feature-board'
|
|
import { FeatureStep, featureSteps } from '@/modules/feature/feature-steps'
|
|
import { Strategy } from '@/modules/lean/strategy'
|
|
import { sumElements } from '@/utils'
|
|
import { defineStore } from 'pinia'
|
|
|
|
type State = {
|
|
steps: FeatureStep[]
|
|
features: Feature[]
|
|
backlog: Feature[]
|
|
meta: {
|
|
totalDays: number
|
|
daysWithProblemSolving: number
|
|
strategy: Record<Strategy, number>
|
|
}
|
|
}
|
|
|
|
const resetMeta = (): State['meta'] => ({
|
|
totalDays: 0,
|
|
daysWithProblemSolving: 0,
|
|
strategy: {
|
|
push: 0,
|
|
pull: 0,
|
|
'problem-solving': 0
|
|
}
|
|
})
|
|
|
|
export const useFeatureStore = defineStore('feature', {
|
|
state: (): State => ({
|
|
steps: [],
|
|
features: [],
|
|
backlog: [],
|
|
meta: resetMeta()
|
|
}),
|
|
actions: {
|
|
initBoard() {
|
|
this.backlog = newBoard()
|
|
this.steps = featureSteps
|
|
this.features = initBoard(this.steps, this.backlog)
|
|
this.meta = resetMeta()
|
|
},
|
|
nextDay(strategy: Strategy) {
|
|
this.meta.totalDays++
|
|
this.meta.strategy[strategy]++
|
|
|
|
if (strategy === 'problem-solving') {
|
|
this.meta.daysWithProblemSolving++
|
|
return
|
|
}
|
|
|
|
this.features = nextDay({
|
|
backlog: this.backlog,
|
|
features: this.features,
|
|
steps: this.steps,
|
|
initialStep: this.steps[0].stepIndex,
|
|
strategy,
|
|
daysWithProblemSolving: this.meta.daysWithProblemSolving
|
|
})
|
|
}
|
|
},
|
|
getters: {
|
|
meanComplexity: (state) => {
|
|
return (
|
|
Math.round(
|
|
100 *
|
|
(sumElements(state.features.map((feature) => feature.complexity)) /
|
|
state.features.length)
|
|
) / 100
|
|
)
|
|
},
|
|
meanLeadTime: (state) => {
|
|
return (
|
|
Math.round(
|
|
100 *
|
|
(sumElements(state.features.map((feature) => feature.leadTime)) /
|
|
state.features.length)
|
|
) / 100
|
|
)
|
|
},
|
|
featuresGroupedByStep: (state) => {
|
|
const groupedByStep: Record<number, Feature[]> = {}
|
|
|
|
state.features.forEach((feature) => {
|
|
if (!groupedByStep[feature.step]) {
|
|
groupedByStep[feature.step] = [feature]
|
|
} else {
|
|
groupedByStep[feature.step].push(feature)
|
|
}
|
|
})
|
|
|
|
return groupedByStep
|
|
}
|
|
}
|
|
})
|