@techsio/ui-kit 0.44.0 → 0.44.1

package/dist/internal/date-picker-coordinator.js

@@ -0,0 +1,166 @@
+import { Time, toCalendarDateTime } from "@internationalized/date";
+function createDatePickerCoordinatorState() {
+    return {
+        draft: null
+    };
+}
+function datePickerCoordinatorReducer(state, action) {
+    if ("open" === action.type || "resync" === action.type) return {
+        draft: {
+            baseline: action.value,
+            candidate: action.value
+        }
+    };
+    if ("edit" === action.type && state.draft) return {
+        draft: {
+            ...state.draft,
+            candidate: action.value,
+            timeParts: null === action.value ? void 0 : state.draft.timeParts
+        }
+    };
+    if ("edit-time" === action.type && state.draft?.candidate) {
+        const index = action.index ?? 0;
+        const hourCycle = action.hourCycle ?? 24;
+        const timeParts = {
+            ...getDatePickerDraftTimeParts(state, hourCycle, index),
+            [action.part]: action.value
+        };
+        const requiredParts = getRequiredTimeParts(action.granularity, hourCycle);
+        const isComplete = requiredParts.every((part)=>"number" == typeof timeParts[part]);
+        let candidate = state.draft.candidate;
+        const endpoint = getCandidateAt(candidate, index);
+        if (isComplete && endpoint) {
+            const time = {
+                hour: 12 === hourCycle ? (timeParts.hour ?? 12) % 12 + (timeParts.dayPeriod ?? 0) : timeParts.hour ?? 0,
+                minute: timeParts.minute ?? 0,
+                second: timeParts.second ?? 0
+            };
+            const timedEndpoint = isTimedDateValue(endpoint) ? endpoint.set(time) : toCalendarDateTime(endpoint, new Time(time.hour, time.minute, time.second));
+            candidate = setCandidateAt(candidate, index, timedEndpoint);
+        }
+        return {
+            draft: {
+                ...state.draft,
+                candidate,
+                timeGranularity: action.granularity,
+                timeHourCycle: hourCycle,
+                timeParts: {
+                    ...state.draft.timeParts,
+                    [index]: timeParts
+                }
+            }
+        };
+    }
+    if ("discard" === action.type) return createDatePickerCoordinatorState();
+    return state;
+}
+function getCandidateAt(candidate, index) {
+    if (isCandidateArray(candidate)) return candidate[index];
+    return 0 === index ? candidate : void 0;
+}
+function setCandidateAt(candidate, index, value) {
+    if (!isCandidateArray(candidate)) return 0 === index ? value : candidate;
+    const nextCandidate = [
+        ...candidate
+    ];
+    nextCandidate[index] = value;
+    return nextCandidate;
+}
+function candidateValues(candidate) {
+    if (isCandidateArray(candidate)) return candidate;
+    return candidate ? [
+        candidate
+    ] : [];
+}
+function isCandidateArray(candidate) {
+    return Array.isArray(candidate);
+}
+function dateValuesEqual(left, right) {
+    const leftValues = candidateValues(left);
+    const rightValues = candidateValues(right);
+    return leftValues.length === rightValues.length && leftValues.every((value, index)=>value.toString() === rightValues[index]?.toString());
+}
+function isDatePickerDraftDirty(state) {
+    if (!state.draft) return false;
+    return !dateValuesEqual(state.draft.baseline, state.draft.candidate) || areDraftTimePartsDirty(state.draft);
+}
+function canConfirmDatePickerDraft(state, isTimeUnavailable) {
+    if (!isDatePickerDraftDirty(state)) return false;
+    const candidate = state.draft?.candidate;
+    if (null === candidate) return true;
+    const values = candidateValues(candidate);
+    if (isCandidateArray(candidate) && 2 !== values.length) return false;
+    const [startValue, endValue] = values;
+    if (startValue && endValue && startValue.compare(endValue) > 0) return false;
+    const timedValues = values.filter(isTimedDateValue);
+    if (timedValues.length !== values.length) return false;
+    const firstTimedValue = timedValues[0];
+    const secondTimedValue = timedValues[1];
+    if (firstTimedValue && secondTimedValue && "timeZone" in firstTimedValue !== "timeZone" in secondTimedValue) return false;
+    return timedValues.every((value, index)=>{
+        if (index > 1) return false;
+        const candidateIndex = 0 === index ? 0 : 1;
+        if (state.draft?.timeGranularity && !getRequiredTimeParts(state.draft.timeGranularity, state.draft.timeHourCycle).every((part)=>"number" == typeof getDatePickerDraftTimeParts(state, state.draft?.timeHourCycle, candidateIndex)[part])) return false;
+        return !(isTimeUnavailable?.(value, candidateIndex) ?? false);
+    });
+}
+function isTimedDateValue(value) {
+    return null != value && "hour" in value;
+}
+function getDatePickerDraftTimeParts(state, hourCycle = 24, index = 0) {
+    const candidate = getCandidateAt(state.draft?.candidate, index);
+    const candidateParts = isTimedDateValue(candidate) ? {
+        dayPeriod: 12 === hourCycle ? candidate.hour >= 12 ? 12 : 0 : void 0,
+        hour: 12 === hourCycle ? candidate.hour % 12 || 12 : candidate.hour,
+        minute: candidate.minute,
+        second: candidate.second
+    } : {};
+    return {
+        ...candidateParts,
+        ...state.draft?.timeParts?.[index]
+    };
+}
+function getRequiredTimeParts(granularity, hourCycle = 24) {
+    const hourParts = 12 === hourCycle ? [
+        "hour",
+        "dayPeriod"
+    ] : [
+        "hour"
+    ];
+    if ("hour" === granularity) return hourParts;
+    if ("minute" === granularity) return [
+        ...hourParts,
+        "minute"
+    ];
+    return [
+        ...hourParts,
+        "minute",
+        "second"
+    ];
+}
+function areDraftTimePartsDirty(draft) {
+    if (!draft.timeParts) return false;
+    const indices = [
+        0,
+        1
+    ];
+    const parts = [
+        "hour",
+        "minute",
+        "second",
+        "dayPeriod"
+    ];
+    return indices.some((index)=>{
+        const timeParts = draft.timeParts?.[index];
+        if (!timeParts) return false;
+        const baseline = getCandidateAt(draft.baseline, index);
+        const baselineParts = isTimedDateValue(baseline) ? {
+            dayPeriod: 12 === draft.timeHourCycle ? baseline.hour >= 12 ? 12 : 0 : void 0,
+            hour: 12 === draft.timeHourCycle ? baseline.hour % 12 || 12 : baseline.hour,
+            minute: baseline.minute,
+            second: baseline.second
+        } : {};
+        return parts.some((part)=>Object.hasOwn(timeParts, part) && baselineParts[part] !== timeParts[part]);
+    });
+}
+export { canConfirmDatePickerDraft, createDatePickerCoordinatorState, datePickerCoordinatorReducer, getDatePickerDraftTimeParts, isDatePickerDraftDirty, isTimedDateValue };