@aiquants/period-slider 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +389 -0
- package/dist/DateSelector.d.ts +45 -0
- package/dist/DateSelector.d.ts.map +1 -0
- package/dist/MonthSelector.d.ts +43 -0
- package/dist/MonthSelector.d.ts.map +1 -0
- package/dist/PeriodSlider.d.ts +384 -0
- package/dist/PeriodSlider.d.ts.map +1 -0
- package/dist/YearSelector.d.ts +36 -0
- package/dist/YearSelector.d.ts.map +1 -0
- package/dist/index.cjs +1 -0
- package/dist/index.d.ts +21 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +1770 -0
- package/dist/period-slider.css +1 -0
- package/dist/styles/period-slider.css +2 -0
- package/dist/styles/period-slider.standalone.css +3 -0
- package/dist/usePeriodSlider.d.ts +213 -0
- package/dist/usePeriodSlider.d.ts.map +1 -0
- package/package.json +98 -0
- package/src/DateSelector.tsx +414 -0
- package/src/MonthSelector.tsx +303 -0
- package/src/PeriodSlider.tsx +2557 -0
- package/src/YearSelector.tsx +168 -0
- package/src/index.ts +67 -0
- package/src/styles/components.entry.css +10 -0
- package/src/styles/period-slider.css +910 -0
- package/src/styles/standalone.entry.css +10 -0
- package/src/usePeriodSlider.ts +692 -0
|
@@ -0,0 +1,692 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @fileoverview Custom React Hooks for PeriodSlider State Management
|
|
3
|
+
* @package @aiquants/period-slider
|
|
4
|
+
*
|
|
5
|
+
* Provides ready-to-use custom hooks that eliminate boilerplate state management
|
|
6
|
+
* for Range, Point, and Vernier dual-scale PeriodSlider components.
|
|
7
|
+
*
|
|
8
|
+
* レンジ・ポイント・ノギス型 2 段スケール PeriodSlider のステート管理ボイラープレートを
|
|
9
|
+
* 最小化する標準 React カスタムフック群を提供します。
|
|
10
|
+
*/
|
|
11
|
+
|
|
12
|
+
import type React from "react"
|
|
13
|
+
import { useCallback, useMemo, useRef, useState } from "react"
|
|
14
|
+
import { addUnit, type PeriodSliderPointProps, type PeriodSliderRangeProps, type PeriodSliderUnit, type PeriodSliderVernierProps } from "./PeriodSlider"
|
|
15
|
+
|
|
16
|
+
// ======================================================================
|
|
17
|
+
// 1. Range Mode Hook (usePeriodSliderRange)
|
|
18
|
+
// ======================================================================
|
|
19
|
+
|
|
20
|
+
export interface UsePeriodSliderRangeOptions extends Partial<Omit<PeriodSliderRangeProps, "mode" | "unit" | "range" | "lowerDate" | "upperDate" | "onChangeRange" | "onChangeRangeTuple" | "onChange">> {
|
|
21
|
+
/** Time resolution unit / 時間解像度単位 */
|
|
22
|
+
unit: PeriodSliderUnit
|
|
23
|
+
/** Initial selected range [lower, upper] / 初期選択期間 */
|
|
24
|
+
initialRange?: [Date, Date]
|
|
25
|
+
/** Initial selected range alias / 初期選択期間 (エイリアス) */
|
|
26
|
+
defaultRange?: [Date, Date]
|
|
27
|
+
/** Minimum selectable boundary date / 選択可能下限日付 */
|
|
28
|
+
minDate?: Date
|
|
29
|
+
/** Maximum selectable boundary date / 選択可能上限日付 */
|
|
30
|
+
maxDate?: Date
|
|
31
|
+
/** Callback triggered when range changes / 期間変更時コールバック */
|
|
32
|
+
onChangeRange?: (lower: Date, upper: Date) => void
|
|
33
|
+
/** Callback triggered with tuple when range changes / 期間変更時タプルコールバック */
|
|
34
|
+
onChangeRangeTuple?: (range: [Date, Date]) => void
|
|
35
|
+
/** Callback alias when range changes / 期間変更時コールバック (エイリアス) */
|
|
36
|
+
onChange?: (range: [Date, Date]) => void
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
export interface SelectorProps {
|
|
40
|
+
value: Date
|
|
41
|
+
onChange: (date: Date) => void
|
|
42
|
+
minDate?: Date
|
|
43
|
+
maxDate?: Date
|
|
44
|
+
unit?: PeriodSliderUnit
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
export interface UsePeriodSliderRangeReturn {
|
|
48
|
+
/** Current selected range tuple / 現在の選択期間タプル */
|
|
49
|
+
range: [Date, Date]
|
|
50
|
+
/** Current lower date / 現在の選択下限日付 */
|
|
51
|
+
lowerDate: Date
|
|
52
|
+
/** Current upper date / 現在の選択上限日付 */
|
|
53
|
+
upperDate: Date
|
|
54
|
+
/** State updater for full range / 期間更新関数 */
|
|
55
|
+
setRange: React.Dispatch<React.SetStateAction<[Date, Date]>>
|
|
56
|
+
/** State updater for lower date with automatic boundary adjustment / 下限日付更新関数 */
|
|
57
|
+
setLowerDate: (date: Date) => void
|
|
58
|
+
/** State updater for upper date with automatic boundary adjustment / 上限日付更新関数 */
|
|
59
|
+
setUpperDate: (date: Date) => void
|
|
60
|
+
/** Shift entire range forward/backward by delta units / 期間幅を維持したまま delta 単位シフト */
|
|
61
|
+
shiftRange: (delta: number) => void
|
|
62
|
+
/** Reset range to initial values / 初期期間へリセット */
|
|
63
|
+
resetRange: () => void
|
|
64
|
+
/** Pre-configured props for start selector (YearSelector, MonthSelector, DateSelector) / 開始セレクタ用 Props */
|
|
65
|
+
startSelectorProps: SelectorProps
|
|
66
|
+
/** Pre-configured props for end selector (YearSelector, MonthSelector, DateSelector) / 終了セレクタ用 Props */
|
|
67
|
+
endSelectorProps: SelectorProps
|
|
68
|
+
/** Pre-configured props to spread directly onto PeriodSlider / PeriodSlider に直接スプレッド可能な Props */
|
|
69
|
+
sliderProps: PeriodSliderRangeProps
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
function clampDate(date: Date, min?: Date, max?: Date): Date {
|
|
73
|
+
if (min && date < min) return min
|
|
74
|
+
if (max && date > max) return max
|
|
75
|
+
return date
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
/**
|
|
79
|
+
* Custom hook to manage state and props for a range PeriodSlider.
|
|
80
|
+
* Range モード PeriodSlider のステート管理と Props 生成を行うカスタムフック。
|
|
81
|
+
*
|
|
82
|
+
* @example
|
|
83
|
+
* ```tsx
|
|
84
|
+
* const { sliderProps, startSelectorProps, endSelectorProps } = usePeriodSliderRange({
|
|
85
|
+
* unit: "month",
|
|
86
|
+
* initialRange: [new Date(2023, 0, 1), new Date(2024, 0, 1)],
|
|
87
|
+
* })
|
|
88
|
+
* return (
|
|
89
|
+
* <div>
|
|
90
|
+
* <MonthSelector {...startSelectorProps} />
|
|
91
|
+
* <PeriodSlider {...sliderProps} />
|
|
92
|
+
* <MonthSelector {...endSelectorProps} />
|
|
93
|
+
* </div>
|
|
94
|
+
* )
|
|
95
|
+
* ```
|
|
96
|
+
*/
|
|
97
|
+
export function usePeriodSliderRange(options: UsePeriodSliderRangeOptions): UsePeriodSliderRangeReturn {
|
|
98
|
+
const { unit, initialRange: rawInitialRange, defaultRange, minDate, maxDate, onChangeRange, onChangeRangeTuple, onChange, ...restUiProps } = options
|
|
99
|
+
|
|
100
|
+
const resolvedInitialRange: [Date, Date] = rawInitialRange ?? defaultRange ?? [minDate ?? new Date(), maxDate ?? new Date()]
|
|
101
|
+
const initialRangeRef = useRef<[Date, Date]>(resolvedInitialRange)
|
|
102
|
+
const [range, setRange] = useState<[Date, Date]>(resolvedInitialRange)
|
|
103
|
+
const rangeRef = useRef<[Date, Date]>(range)
|
|
104
|
+
rangeRef.current = range
|
|
105
|
+
|
|
106
|
+
const onChangeRangeRef = useRef(onChangeRange)
|
|
107
|
+
onChangeRangeRef.current = onChangeRange
|
|
108
|
+
const onChangeRangeTupleRef = useRef(onChangeRangeTuple)
|
|
109
|
+
onChangeRangeTupleRef.current = onChangeRangeTuple
|
|
110
|
+
const onChangeRef = useRef(onChange)
|
|
111
|
+
onChangeRef.current = onChange
|
|
112
|
+
|
|
113
|
+
const setLowerDate = useCallback((newLower: Date) => {
|
|
114
|
+
const current = rangeRef.current
|
|
115
|
+
let nextUpper = current[1]
|
|
116
|
+
if (newLower.getTime() > nextUpper.getTime()) {
|
|
117
|
+
nextUpper = newLower
|
|
118
|
+
}
|
|
119
|
+
const nextRange: [Date, Date] = [newLower, nextUpper]
|
|
120
|
+
setRange(nextRange)
|
|
121
|
+
onChangeRangeRef.current?.(nextRange[0], nextRange[1])
|
|
122
|
+
onChangeRangeTupleRef.current?.(nextRange)
|
|
123
|
+
onChangeRef.current?.(nextRange)
|
|
124
|
+
}, [])
|
|
125
|
+
|
|
126
|
+
const setUpperDate = useCallback((newUpper: Date) => {
|
|
127
|
+
const current = rangeRef.current
|
|
128
|
+
let nextLower = current[0]
|
|
129
|
+
if (newUpper.getTime() < nextLower.getTime()) {
|
|
130
|
+
nextLower = newUpper
|
|
131
|
+
}
|
|
132
|
+
const nextRange: [Date, Date] = [nextLower, newUpper]
|
|
133
|
+
setRange(nextRange)
|
|
134
|
+
onChangeRangeRef.current?.(nextRange[0], nextRange[1])
|
|
135
|
+
onChangeRangeTupleRef.current?.(nextRange)
|
|
136
|
+
onChangeRef.current?.(nextRange)
|
|
137
|
+
}, [])
|
|
138
|
+
|
|
139
|
+
const handleSliderChange = useCallback((lower: Date, upper: Date) => {
|
|
140
|
+
const nextRange: [Date, Date] = [lower, upper]
|
|
141
|
+
setRange(nextRange)
|
|
142
|
+
onChangeRangeRef.current?.(lower, upper)
|
|
143
|
+
onChangeRangeTupleRef.current?.(nextRange)
|
|
144
|
+
onChangeRef.current?.(nextRange)
|
|
145
|
+
}, [])
|
|
146
|
+
|
|
147
|
+
const handleSliderChangeTuple = useCallback((nextRange: [Date, Date]) => {
|
|
148
|
+
setRange(nextRange)
|
|
149
|
+
onChangeRangeRef.current?.(nextRange[0], nextRange[1])
|
|
150
|
+
onChangeRangeTupleRef.current?.(nextRange)
|
|
151
|
+
onChangeRef.current?.(nextRange)
|
|
152
|
+
}, [])
|
|
153
|
+
|
|
154
|
+
const shiftRange = useCallback(
|
|
155
|
+
(delta: number) => {
|
|
156
|
+
const current = rangeRef.current
|
|
157
|
+
const newLower = addUnit(unit, current[0], delta)
|
|
158
|
+
const newUpper = addUnit(unit, current[1], delta)
|
|
159
|
+
const clampedLower = clampDate(newLower, minDate, maxDate)
|
|
160
|
+
const clampedUpper = clampDate(newUpper, minDate, maxDate)
|
|
161
|
+
const nextRange: [Date, Date] = [clampedLower, clampedUpper]
|
|
162
|
+
setRange(nextRange)
|
|
163
|
+
onChangeRangeRef.current?.(nextRange[0], nextRange[1])
|
|
164
|
+
onChangeRangeTupleRef.current?.(nextRange)
|
|
165
|
+
onChangeRef.current?.(nextRange)
|
|
166
|
+
},
|
|
167
|
+
[unit, minDate, maxDate],
|
|
168
|
+
)
|
|
169
|
+
|
|
170
|
+
const resetRange = useCallback(() => {
|
|
171
|
+
const resetVal = initialRangeRef.current
|
|
172
|
+
setRange(resetVal)
|
|
173
|
+
onChangeRangeRef.current?.(resetVal[0], resetVal[1])
|
|
174
|
+
onChangeRangeTupleRef.current?.(resetVal)
|
|
175
|
+
onChangeRef.current?.(resetVal)
|
|
176
|
+
}, [])
|
|
177
|
+
|
|
178
|
+
const startSelectorProps = useMemo<SelectorProps>(
|
|
179
|
+
() => ({
|
|
180
|
+
value: range[0],
|
|
181
|
+
onChange: setLowerDate,
|
|
182
|
+
minDate,
|
|
183
|
+
maxDate: range[1],
|
|
184
|
+
unit,
|
|
185
|
+
}),
|
|
186
|
+
[range[0], range[1], setLowerDate, minDate, unit],
|
|
187
|
+
)
|
|
188
|
+
|
|
189
|
+
const endSelectorProps = useMemo<SelectorProps>(
|
|
190
|
+
() => ({
|
|
191
|
+
value: range[1],
|
|
192
|
+
onChange: setUpperDate,
|
|
193
|
+
minDate: range[0],
|
|
194
|
+
maxDate,
|
|
195
|
+
unit,
|
|
196
|
+
}),
|
|
197
|
+
[range[0], range[1], setUpperDate, maxDate, unit],
|
|
198
|
+
)
|
|
199
|
+
|
|
200
|
+
const sliderProps = useMemo<PeriodSliderRangeProps>(
|
|
201
|
+
() => ({
|
|
202
|
+
...restUiProps,
|
|
203
|
+
mode: "range",
|
|
204
|
+
unit,
|
|
205
|
+
range,
|
|
206
|
+
minDate,
|
|
207
|
+
maxDate,
|
|
208
|
+
onChangeRange: handleSliderChange,
|
|
209
|
+
onChangeRangeTuple: handleSliderChangeTuple,
|
|
210
|
+
onChange: handleSliderChangeTuple,
|
|
211
|
+
}),
|
|
212
|
+
[restUiProps, unit, range, minDate, maxDate, handleSliderChange, handleSliderChangeTuple],
|
|
213
|
+
)
|
|
214
|
+
|
|
215
|
+
return {
|
|
216
|
+
range,
|
|
217
|
+
lowerDate: range[0],
|
|
218
|
+
upperDate: range[1],
|
|
219
|
+
setRange,
|
|
220
|
+
setLowerDate,
|
|
221
|
+
setUpperDate,
|
|
222
|
+
shiftRange,
|
|
223
|
+
resetRange,
|
|
224
|
+
startSelectorProps,
|
|
225
|
+
endSelectorProps,
|
|
226
|
+
sliderProps,
|
|
227
|
+
}
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
// ======================================================================
|
|
231
|
+
// 2. Point Mode Hook (usePeriodSliderPoint)
|
|
232
|
+
// ======================================================================
|
|
233
|
+
|
|
234
|
+
export interface UsePeriodSliderPointOptions extends Partial<Omit<PeriodSliderPointProps, "mode" | "unit" | "value" | "valueDate" | "onChangePoint" | "onChangeValue" | "onChange">> {
|
|
235
|
+
/** Time resolution unit / 時間解像度単位 */
|
|
236
|
+
unit: PeriodSliderUnit
|
|
237
|
+
/** Initial selected date / 初期選択日 */
|
|
238
|
+
initialValue?: Date
|
|
239
|
+
/** Initial selected date alias (consistent with selectors) / 初期選択日 (セレクタ連携エイリアス) */
|
|
240
|
+
initialDate?: Date
|
|
241
|
+
/** Initial selected date alias (consistent with slider) / 初期選択日 (スライダー連携エイリアス) */
|
|
242
|
+
defaultValue?: Date
|
|
243
|
+
/** Minimum selectable boundary date / 選択可能下限日付 */
|
|
244
|
+
minDate?: Date
|
|
245
|
+
/** Maximum selectable boundary date / 選択可能上限日付 */
|
|
246
|
+
maxDate?: Date
|
|
247
|
+
/** Callback triggered when point changes / 日付変更時コールバック */
|
|
248
|
+
onChangePoint?: (value: Date) => void
|
|
249
|
+
/** Callback triggered when point changes (alias) / 日付変更時コールバック (エイリアス) */
|
|
250
|
+
onChangeValue?: (value: Date) => void
|
|
251
|
+
/** Callback alias when point changes / 日付変更時コールバック (エイリアス) */
|
|
252
|
+
onChange?: (value: Date) => void
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
export interface UsePeriodSliderPointReturn {
|
|
256
|
+
/** Current selected point date / 現在の選択日付 */
|
|
257
|
+
value: Date
|
|
258
|
+
/** State updater for point / 日付更新関数 */
|
|
259
|
+
setValue: React.Dispatch<React.SetStateAction<Date>>
|
|
260
|
+
/** Shift point by delta units / 日付を delta 単位シフト */
|
|
261
|
+
shiftValue: (delta: number) => void
|
|
262
|
+
/** Reset to initial value / 初期日付へリセット */
|
|
263
|
+
resetValue: () => void
|
|
264
|
+
/** Pre-configured props for selector (YearSelector, MonthSelector, DateSelector) / セレクタ用 Props */
|
|
265
|
+
selectorProps: SelectorProps
|
|
266
|
+
/** Pre-configured props to spread directly onto PeriodSlider / PeriodSlider に直接スプレッド可能な Props */
|
|
267
|
+
sliderProps: PeriodSliderPointProps
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
/**
|
|
271
|
+
* Custom hook to manage state and props for a point PeriodSlider.
|
|
272
|
+
* Point モード PeriodSlider のステート管理と Props 生成を行うカスタムフック。
|
|
273
|
+
*
|
|
274
|
+
* @example
|
|
275
|
+
* ```tsx
|
|
276
|
+
* const { value, sliderProps, selectorProps } = usePeriodSliderPoint({
|
|
277
|
+
* unit: "month",
|
|
278
|
+
* initialValue: new Date(2024, 5, 1),
|
|
279
|
+
* })
|
|
280
|
+
* return (
|
|
281
|
+
* <div>
|
|
282
|
+
* <MonthSelector {...selectorProps} />
|
|
283
|
+
* <PeriodSlider {...sliderProps} />
|
|
284
|
+
* </div>
|
|
285
|
+
* )
|
|
286
|
+
* ```
|
|
287
|
+
*/
|
|
288
|
+
export function usePeriodSliderPoint(options: UsePeriodSliderPointOptions): UsePeriodSliderPointReturn {
|
|
289
|
+
const { unit, initialValue: rawInitialValue, initialDate, defaultValue, minDate, maxDate, onChangePoint, onChangeValue, onChange, ...restUiProps } = options
|
|
290
|
+
|
|
291
|
+
const resolvedInitialValue: Date = rawInitialValue ?? initialDate ?? defaultValue ?? minDate ?? new Date()
|
|
292
|
+
const initialValueRef = useRef<Date>(resolvedInitialValue)
|
|
293
|
+
const [value, setValue] = useState<Date>(resolvedInitialValue)
|
|
294
|
+
const valueRef = useRef<Date>(value)
|
|
295
|
+
valueRef.current = value
|
|
296
|
+
|
|
297
|
+
const onChangePointRef = useRef(onChangePoint)
|
|
298
|
+
onChangePointRef.current = onChangePoint
|
|
299
|
+
const onChangeValueRef = useRef(onChangeValue)
|
|
300
|
+
onChangeValueRef.current = onChangeValue
|
|
301
|
+
const onChangeRef = useRef(onChange)
|
|
302
|
+
onChangeRef.current = onChange
|
|
303
|
+
|
|
304
|
+
const handlePointChange = useCallback((nextDate: Date) => {
|
|
305
|
+
setValue(nextDate)
|
|
306
|
+
onChangePointRef.current?.(nextDate)
|
|
307
|
+
onChangeValueRef.current?.(nextDate)
|
|
308
|
+
onChangeRef.current?.(nextDate)
|
|
309
|
+
}, [])
|
|
310
|
+
|
|
311
|
+
const shiftValue = useCallback(
|
|
312
|
+
(delta: number) => {
|
|
313
|
+
const current = valueRef.current
|
|
314
|
+
const newDate = addUnit(unit, current, delta)
|
|
315
|
+
const clamped = clampDate(newDate, minDate, maxDate)
|
|
316
|
+
setValue(clamped)
|
|
317
|
+
onChangePointRef.current?.(clamped)
|
|
318
|
+
onChangeValueRef.current?.(clamped)
|
|
319
|
+
onChangeRef.current?.(clamped)
|
|
320
|
+
},
|
|
321
|
+
[unit, minDate, maxDate],
|
|
322
|
+
)
|
|
323
|
+
|
|
324
|
+
const resetValue = useCallback(() => {
|
|
325
|
+
const resetVal = initialValueRef.current
|
|
326
|
+
setValue(resetVal)
|
|
327
|
+
onChangePointRef.current?.(resetVal)
|
|
328
|
+
onChangeValueRef.current?.(resetVal)
|
|
329
|
+
onChangeRef.current?.(resetVal)
|
|
330
|
+
}, [])
|
|
331
|
+
|
|
332
|
+
const selectorProps = useMemo<SelectorProps>(
|
|
333
|
+
() => ({
|
|
334
|
+
value,
|
|
335
|
+
onChange: handlePointChange,
|
|
336
|
+
minDate,
|
|
337
|
+
maxDate,
|
|
338
|
+
unit,
|
|
339
|
+
}),
|
|
340
|
+
[value, handlePointChange, minDate, maxDate, unit],
|
|
341
|
+
)
|
|
342
|
+
|
|
343
|
+
const sliderProps = useMemo<PeriodSliderPointProps>(
|
|
344
|
+
() => ({
|
|
345
|
+
...restUiProps,
|
|
346
|
+
mode: "point",
|
|
347
|
+
unit,
|
|
348
|
+
value,
|
|
349
|
+
minDate,
|
|
350
|
+
maxDate,
|
|
351
|
+
onChangePoint: handlePointChange,
|
|
352
|
+
onChangeValue: handlePointChange,
|
|
353
|
+
onChange: handlePointChange,
|
|
354
|
+
}),
|
|
355
|
+
[restUiProps, unit, value, minDate, maxDate, handlePointChange],
|
|
356
|
+
)
|
|
357
|
+
|
|
358
|
+
return {
|
|
359
|
+
value,
|
|
360
|
+
setValue,
|
|
361
|
+
shiftValue,
|
|
362
|
+
resetValue,
|
|
363
|
+
selectorProps,
|
|
364
|
+
sliderProps,
|
|
365
|
+
}
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
// ======================================================================
|
|
369
|
+
// 3. Vernier Dual-Scale Hook (useVernierSlider)
|
|
370
|
+
// ======================================================================
|
|
371
|
+
|
|
372
|
+
export interface UseVernierSliderOptions
|
|
373
|
+
extends Partial<
|
|
374
|
+
Omit<PeriodSliderVernierProps, "mode" | "minDate" | "maxDate" | "macroRange" | "microRange" | "onChangeMacroRange" | "onChangeMacroRangeTuple" | "onChangeMacro" | "onChangeRange" | "onChangeRangeTuple" | "onChangeMicroRange" | "onChangeMicroRangeTuple" | "onChangeMicro">
|
|
375
|
+
> {
|
|
376
|
+
/** Minimum selectable boundary date for entire macro range / 全期間マクロの下限日付 (必須) */
|
|
377
|
+
minDate: Date
|
|
378
|
+
/** Maximum selectable boundary date for entire macro range / 全期間マクロの上限日付 (必須) */
|
|
379
|
+
maxDate: Date
|
|
380
|
+
/** Initial macro window range [start, end] / 初期マクロ窓期間 */
|
|
381
|
+
initialMacroRange?: [Date, Date]
|
|
382
|
+
/** Initial macro window range alias / 初期マクロ窓期間 (エイリアス) */
|
|
383
|
+
defaultMacroRange?: [Date, Date]
|
|
384
|
+
/** Initial micro selected range [lower, upper] / 初期ミクロ選択期間 */
|
|
385
|
+
initialMicroRange?: [Date, Date]
|
|
386
|
+
/** Initial micro selected range alias / 初期ミクロ選択期間 (エイリアス) */
|
|
387
|
+
defaultMicroRange?: [Date, Date]
|
|
388
|
+
/** Base time resolution unit / 基本単位 (既定: "month") */
|
|
389
|
+
unit?: PeriodSliderUnit
|
|
390
|
+
/** Macro scale unit / マクロ単位 */
|
|
391
|
+
macroUnit?: PeriodSliderUnit
|
|
392
|
+
/** Micro scale unit / ミクロ単位 */
|
|
393
|
+
microUnit?: PeriodSliderUnit
|
|
394
|
+
/** Callback triggered when macro window changes / マクロ窓変更時コールバック */
|
|
395
|
+
onChangeMacroRange?: (lower: Date, upper: Date) => void
|
|
396
|
+
/** Callback triggered with tuple when macro window changes / マクロ窓変更時タプルコールバック */
|
|
397
|
+
onChangeMacroRangeTuple?: (range: [Date, Date]) => void
|
|
398
|
+
/** Symmetrical callback alias for macro window / マクロ窓変更時コールバック (エイリアス) */
|
|
399
|
+
onChangeMacro?: (range: [Date, Date]) => void
|
|
400
|
+
/** Callback triggered when micro range changes / ミクロ選択範囲変更時コールバック */
|
|
401
|
+
onChangeRange?: (lower: Date, upper: Date) => void
|
|
402
|
+
/** Callback triggered with tuple when micro range changes / ミクロ選択範囲変更時タプルコールバック */
|
|
403
|
+
onChangeRangeTuple?: (range: [Date, Date]) => void
|
|
404
|
+
/** Symmetrical callback for micro range / ミクロ選択範囲変更時コールバック */
|
|
405
|
+
onChangeMicroRange?: (lower: Date, upper: Date) => void
|
|
406
|
+
/** Symmetrical tuple callback for micro range / ミクロ選択範囲変更時タプルコールバック */
|
|
407
|
+
onChangeMicroRangeTuple?: (range: [Date, Date]) => void
|
|
408
|
+
/** Symmetrical alias for micro range / ミクロ選択範囲変更時コールバック (エイリアス) */
|
|
409
|
+
onChangeMicro?: (range: [Date, Date]) => void
|
|
410
|
+
}
|
|
411
|
+
|
|
412
|
+
export interface UseVernierSliderReturn {
|
|
413
|
+
/** Macro window range tuple / マクロ窓期間タプル */
|
|
414
|
+
macroRange: [Date, Date]
|
|
415
|
+
/** State updater for macro range / マクロ窓更新関数 */
|
|
416
|
+
setMacroRange: React.Dispatch<React.SetStateAction<[Date, Date]>>
|
|
417
|
+
/** Micro selected range tuple / ミクロ選択期間タプル */
|
|
418
|
+
microRange: [Date, Date]
|
|
419
|
+
/** State updater for micro range / ミクロ選択範囲更新関数 */
|
|
420
|
+
setMicroRange: React.Dispatch<React.SetStateAction<[Date, Date]>>
|
|
421
|
+
/** Set macro lower date / マクロ開始日更新 */
|
|
422
|
+
setMacroLowerDate: (date: Date) => void
|
|
423
|
+
/** Set macro upper date / マクロ終了日更新 */
|
|
424
|
+
setMacroUpperDate: (date: Date) => void
|
|
425
|
+
/** Set micro lower date / ミクロ開始日更新 */
|
|
426
|
+
setMicroLowerDate: (date: Date) => void
|
|
427
|
+
/** Set micro upper date / ミクロ終了日更新 */
|
|
428
|
+
setMicroUpperDate: (date: Date) => void
|
|
429
|
+
/** Shift macro range by delta units / マクロ窓をシフト */
|
|
430
|
+
shiftMacroRange: (delta: number) => void
|
|
431
|
+
/** Shift micro range by delta units / ミクロ選択範囲をシフト */
|
|
432
|
+
shiftMicroRange: (delta: number) => void
|
|
433
|
+
/** Reset to initial macro and micro ranges / 初期状態へリセット */
|
|
434
|
+
resetVernier: () => void
|
|
435
|
+
/** Pre-configured props for macro start selector / マクロ開始日セレクタ用 Props */
|
|
436
|
+
macroStartSelectorProps: SelectorProps
|
|
437
|
+
/** Pre-configured props for macro end selector / マクロ終了日セレクタ用 Props */
|
|
438
|
+
macroEndSelectorProps: SelectorProps
|
|
439
|
+
/** Pre-configured props for micro start selector / ミクロ開始日セレクタ用 Props */
|
|
440
|
+
microStartSelectorProps: SelectorProps
|
|
441
|
+
/** Pre-configured props for micro end selector / ミクロ終了日セレクタ用 Props */
|
|
442
|
+
microEndSelectorProps: SelectorProps
|
|
443
|
+
/** Pre-configured props to spread directly onto PeriodSlider / PeriodSlider に直接スプレッド可能な Props */
|
|
444
|
+
sliderProps: PeriodSliderVernierProps
|
|
445
|
+
}
|
|
446
|
+
|
|
447
|
+
/**
|
|
448
|
+
* Custom hook to manage state and props for a Vernier dual-scale PeriodSlider.
|
|
449
|
+
* Vernier 2 段スケール PeriodSlider のステート管理と Props 生成を行うカスタムフック。
|
|
450
|
+
*
|
|
451
|
+
* @example
|
|
452
|
+
* ```tsx
|
|
453
|
+
* const { macroRange, microRange, sliderProps, macroStartSelectorProps, macroEndSelectorProps } = useVernierSlider({
|
|
454
|
+
* minDate: new Date(2015, 0, 1),
|
|
455
|
+
* maxDate: new Date(2030, 11, 31),
|
|
456
|
+
* initialMacroRange: [new Date(2020, 0, 1), new Date(2026, 0, 1)],
|
|
457
|
+
* initialMicroRange: [new Date(2022, 3, 1), new Date(2024, 8, 1)],
|
|
458
|
+
* macroUnit: "year",
|
|
459
|
+
* microUnit: "month",
|
|
460
|
+
* })
|
|
461
|
+
* return <PeriodSlider {...sliderProps} />
|
|
462
|
+
* ```
|
|
463
|
+
*/
|
|
464
|
+
export function useVernierSlider(options: UseVernierSliderOptions): UseVernierSliderReturn {
|
|
465
|
+
const {
|
|
466
|
+
minDate,
|
|
467
|
+
maxDate,
|
|
468
|
+
initialMacroRange,
|
|
469
|
+
defaultMacroRange,
|
|
470
|
+
initialMicroRange,
|
|
471
|
+
defaultMicroRange,
|
|
472
|
+
unit = "month",
|
|
473
|
+
macroUnit = unit,
|
|
474
|
+
microUnit = unit,
|
|
475
|
+
onChangeMacroRange,
|
|
476
|
+
onChangeMacroRangeTuple,
|
|
477
|
+
onChangeMacro,
|
|
478
|
+
onChangeRange,
|
|
479
|
+
onChangeRangeTuple,
|
|
480
|
+
onChangeMicroRange,
|
|
481
|
+
onChangeMicroRangeTuple,
|
|
482
|
+
onChangeMicro,
|
|
483
|
+
...restUiProps
|
|
484
|
+
} = options
|
|
485
|
+
|
|
486
|
+
const resolvedInitialMacroRange: [Date, Date] = initialMacroRange ?? defaultMacroRange ?? [minDate, maxDate]
|
|
487
|
+
const resolvedInitialMicroRange: [Date, Date] = initialMicroRange ?? defaultMicroRange ?? resolvedInitialMacroRange
|
|
488
|
+
|
|
489
|
+
const initialMacroRef = useRef<[Date, Date]>(resolvedInitialMacroRange)
|
|
490
|
+
const initialMicroRef = useRef<[Date, Date]>(resolvedInitialMicroRange)
|
|
491
|
+
|
|
492
|
+
const [macroRange, setMacroRange] = useState<[Date, Date]>(resolvedInitialMacroRange)
|
|
493
|
+
const [microRange, setMicroRange] = useState<[Date, Date]>(resolvedInitialMicroRange)
|
|
494
|
+
const macroRangeRef = useRef<[Date, Date]>(macroRange)
|
|
495
|
+
macroRangeRef.current = macroRange
|
|
496
|
+
const microRangeRef = useRef<[Date, Date]>(microRange)
|
|
497
|
+
microRangeRef.current = microRange
|
|
498
|
+
|
|
499
|
+
const handleChangeMacroRange = useCallback(
|
|
500
|
+
(lower: Date, upper: Date) => {
|
|
501
|
+
setMacroRange([lower, upper])
|
|
502
|
+
onChangeMacroRange?.(lower, upper)
|
|
503
|
+
onChangeMacroRangeTuple?.([lower, upper])
|
|
504
|
+
onChangeMacro?.([lower, upper])
|
|
505
|
+
},
|
|
506
|
+
[onChangeMacroRange, onChangeMacroRangeTuple, onChangeMacro],
|
|
507
|
+
)
|
|
508
|
+
|
|
509
|
+
const handleChangeMacroRangeTuple = useCallback(
|
|
510
|
+
(r: [Date, Date]) => {
|
|
511
|
+
handleChangeMacroRange(r[0], r[1])
|
|
512
|
+
},
|
|
513
|
+
[handleChangeMacroRange],
|
|
514
|
+
)
|
|
515
|
+
|
|
516
|
+
const handleChangeMicroRange = useCallback(
|
|
517
|
+
(lower: Date, upper: Date) => {
|
|
518
|
+
setMicroRange([lower, upper])
|
|
519
|
+
onChangeRange?.(lower, upper)
|
|
520
|
+
onChangeRangeTuple?.([lower, upper])
|
|
521
|
+
onChangeMicroRange?.(lower, upper)
|
|
522
|
+
onChangeMicroRangeTuple?.([lower, upper])
|
|
523
|
+
onChangeMicro?.([lower, upper])
|
|
524
|
+
},
|
|
525
|
+
[onChangeRange, onChangeRangeTuple, onChangeMicroRange, onChangeMicroRangeTuple, onChangeMicro],
|
|
526
|
+
)
|
|
527
|
+
|
|
528
|
+
const handleChangeMicroRangeTuple = useCallback(
|
|
529
|
+
(r: [Date, Date]) => {
|
|
530
|
+
handleChangeMicroRange(r[0], r[1])
|
|
531
|
+
},
|
|
532
|
+
[handleChangeMicroRange],
|
|
533
|
+
)
|
|
534
|
+
|
|
535
|
+
const setMacroLowerDate = useCallback(
|
|
536
|
+
(date: Date) => {
|
|
537
|
+
const currentUpper = macroRangeRef.current[1]
|
|
538
|
+
const nextLower = date < minDate ? minDate : date
|
|
539
|
+
const nextUpper = date > currentUpper ? date : currentUpper
|
|
540
|
+
handleChangeMacroRange(nextLower, nextUpper)
|
|
541
|
+
},
|
|
542
|
+
[minDate, handleChangeMacroRange],
|
|
543
|
+
)
|
|
544
|
+
|
|
545
|
+
const setMacroUpperDate = useCallback(
|
|
546
|
+
(date: Date) => {
|
|
547
|
+
const currentLower = macroRangeRef.current[0]
|
|
548
|
+
const nextUpper = date > maxDate ? maxDate : date
|
|
549
|
+
const nextLower = date < currentLower ? date : currentLower
|
|
550
|
+
handleChangeMacroRange(nextLower, nextUpper)
|
|
551
|
+
},
|
|
552
|
+
[maxDate, handleChangeMacroRange],
|
|
553
|
+
)
|
|
554
|
+
|
|
555
|
+
const setMicroLowerDate = useCallback(
|
|
556
|
+
(date: Date) => {
|
|
557
|
+
const currentMacro = macroRangeRef.current
|
|
558
|
+
const currentMicro = microRangeRef.current
|
|
559
|
+
const nextLower = date < currentMacro[0] ? currentMacro[0] : date
|
|
560
|
+
const nextUpper = date > currentMicro[1] ? date : currentMicro[1]
|
|
561
|
+
handleChangeMicroRange(nextLower, nextUpper)
|
|
562
|
+
},
|
|
563
|
+
[handleChangeMicroRange],
|
|
564
|
+
)
|
|
565
|
+
|
|
566
|
+
const setMicroUpperDate = useCallback(
|
|
567
|
+
(date: Date) => {
|
|
568
|
+
const currentMacro = macroRangeRef.current
|
|
569
|
+
const currentMicro = microRangeRef.current
|
|
570
|
+
const nextUpper = date > currentMacro[1] ? currentMacro[1] : date
|
|
571
|
+
const nextLower = date < currentMicro[0] ? date : currentMicro[0]
|
|
572
|
+
handleChangeMicroRange(nextLower, nextUpper)
|
|
573
|
+
},
|
|
574
|
+
[handleChangeMicroRange],
|
|
575
|
+
)
|
|
576
|
+
|
|
577
|
+
const shiftMacroRange = useCallback(
|
|
578
|
+
(delta: number) => {
|
|
579
|
+
const current = macroRangeRef.current
|
|
580
|
+
const shiftedLow = addUnit(macroUnit, current[0], delta)
|
|
581
|
+
const shiftedHigh = addUnit(macroUnit, current[1], delta)
|
|
582
|
+
if (shiftedLow < minDate || shiftedHigh > maxDate) return
|
|
583
|
+
handleChangeMacroRange(shiftedLow, shiftedHigh)
|
|
584
|
+
},
|
|
585
|
+
[macroUnit, minDate, maxDate, handleChangeMacroRange],
|
|
586
|
+
)
|
|
587
|
+
|
|
588
|
+
const shiftMicroRange = useCallback(
|
|
589
|
+
(delta: number) => {
|
|
590
|
+
const currentMacro = macroRangeRef.current
|
|
591
|
+
const currentMicro = microRangeRef.current
|
|
592
|
+
const shiftedLow = addUnit(microUnit, currentMicro[0], delta)
|
|
593
|
+
const shiftedHigh = addUnit(microUnit, currentMicro[1], delta)
|
|
594
|
+
if (shiftedLow < currentMacro[0] || shiftedHigh > currentMacro[1]) return
|
|
595
|
+
handleChangeMicroRange(shiftedLow, shiftedHigh)
|
|
596
|
+
},
|
|
597
|
+
[microUnit, handleChangeMicroRange],
|
|
598
|
+
)
|
|
599
|
+
|
|
600
|
+
const resetVernier = useCallback(() => {
|
|
601
|
+
const [initMacroLow, initMacroHigh] = initialMacroRef.current
|
|
602
|
+
const [initMicroLow, initMicroHigh] = initialMicroRef.current
|
|
603
|
+
handleChangeMacroRange(initMacroLow, initMacroHigh)
|
|
604
|
+
handleChangeMicroRange(initMicroLow, initMicroHigh)
|
|
605
|
+
}, [handleChangeMacroRange, handleChangeMicroRange])
|
|
606
|
+
|
|
607
|
+
const macroStartSelectorProps: SelectorProps = useMemo(
|
|
608
|
+
() => ({
|
|
609
|
+
value: macroRange[0],
|
|
610
|
+
onChange: setMacroLowerDate,
|
|
611
|
+
minDate,
|
|
612
|
+
maxDate: macroRange[1],
|
|
613
|
+
unit: macroUnit,
|
|
614
|
+
}),
|
|
615
|
+
[macroRange, setMacroLowerDate, minDate, macroUnit],
|
|
616
|
+
)
|
|
617
|
+
|
|
618
|
+
const macroEndSelectorProps: SelectorProps = useMemo(
|
|
619
|
+
() => ({
|
|
620
|
+
value: macroRange[1],
|
|
621
|
+
onChange: setMacroUpperDate,
|
|
622
|
+
minDate: macroRange[0],
|
|
623
|
+
maxDate,
|
|
624
|
+
unit: macroUnit,
|
|
625
|
+
}),
|
|
626
|
+
[macroRange, setMacroUpperDate, maxDate, macroUnit],
|
|
627
|
+
)
|
|
628
|
+
|
|
629
|
+
const microStartSelectorProps: SelectorProps = useMemo(
|
|
630
|
+
() => ({
|
|
631
|
+
value: microRange[0],
|
|
632
|
+
onChange: setMicroLowerDate,
|
|
633
|
+
minDate: macroRange[0],
|
|
634
|
+
maxDate: microRange[1],
|
|
635
|
+
unit: microUnit,
|
|
636
|
+
}),
|
|
637
|
+
[microRange, setMicroLowerDate, macroRange, microUnit],
|
|
638
|
+
)
|
|
639
|
+
|
|
640
|
+
const microEndSelectorProps: SelectorProps = useMemo(
|
|
641
|
+
() => ({
|
|
642
|
+
value: microRange[1],
|
|
643
|
+
onChange: setMicroUpperDate,
|
|
644
|
+
minDate: microRange[0],
|
|
645
|
+
maxDate: macroRange[1],
|
|
646
|
+
unit: microUnit,
|
|
647
|
+
}),
|
|
648
|
+
[microRange, setMicroUpperDate, macroRange, microUnit],
|
|
649
|
+
)
|
|
650
|
+
|
|
651
|
+
const sliderProps: PeriodSliderVernierProps = useMemo(
|
|
652
|
+
() => ({
|
|
653
|
+
...restUiProps,
|
|
654
|
+
mode: "vernier",
|
|
655
|
+
unit,
|
|
656
|
+
macroUnit,
|
|
657
|
+
microUnit,
|
|
658
|
+
minDate,
|
|
659
|
+
maxDate,
|
|
660
|
+
macroRange,
|
|
661
|
+
microRange,
|
|
662
|
+
onChangeMacroRange: handleChangeMacroRange,
|
|
663
|
+
onChangeMacroRangeTuple: handleChangeMacroRangeTuple,
|
|
664
|
+
onChangeMacro: handleChangeMacroRangeTuple,
|
|
665
|
+
onChangeRange: handleChangeMicroRange,
|
|
666
|
+
onChangeRangeTuple: handleChangeMicroRangeTuple,
|
|
667
|
+
onChangeMicroRange: handleChangeMicroRange,
|
|
668
|
+
onChangeMicroRangeTuple: handleChangeMicroRangeTuple,
|
|
669
|
+
onChangeMicro: handleChangeMicroRangeTuple,
|
|
670
|
+
}),
|
|
671
|
+
[restUiProps, unit, macroUnit, microUnit, minDate, maxDate, macroRange, microRange, handleChangeMacroRange, handleChangeMacroRangeTuple, handleChangeMicroRange, handleChangeMicroRangeTuple],
|
|
672
|
+
)
|
|
673
|
+
|
|
674
|
+
return {
|
|
675
|
+
macroRange,
|
|
676
|
+
setMacroRange,
|
|
677
|
+
microRange,
|
|
678
|
+
setMicroRange,
|
|
679
|
+
setMacroLowerDate,
|
|
680
|
+
setMacroUpperDate,
|
|
681
|
+
setMicroLowerDate,
|
|
682
|
+
setMicroUpperDate,
|
|
683
|
+
shiftMacroRange,
|
|
684
|
+
shiftMicroRange,
|
|
685
|
+
resetVernier,
|
|
686
|
+
macroStartSelectorProps,
|
|
687
|
+
macroEndSelectorProps,
|
|
688
|
+
microStartSelectorProps,
|
|
689
|
+
microEndSelectorProps,
|
|
690
|
+
sliderProps,
|
|
691
|
+
}
|
|
692
|
+
}
|