reka-ui/dist/date/parser.js

Vue port for Radix UI Primitives.

import { t as toDate, a as isZonedDateTime } from './comparators.js';
import { E as EDITABLE_SEGMENT_PARTS, D as DATE_SEGMENT_PARTS, T as TIME_SEGMENT_PARTS, i as isSegmentPart, a as isDateSegmentPart } from './parts.js';
import { g as getPlaceholder } from './placeholders.js';
import { g as getOptsByGranularity, n as normalizeHourCycle } from './utils.js';

const calendarDateTimeGranularities = ["hour", "minute", "second"];
function syncTimeSegmentValues(props) {
  return Object.fromEntries(TIME_SEGMENT_PARTS.map((part) => {
    if (part === "dayPeriod")
      return [part, props.formatter.dayPeriod(toDate(props.value))];
    return [part, props.value[part]];
  }));
}
function syncSegmentValues(props) {
  const { formatter } = props;
  const dateValues = DATE_SEGMENT_PARTS.map((part) => {
    return [part, props.value[part]];
  });
  if ("hour" in props.value) {
    const timeValues = syncTimeSegmentValues({ value: props.value, formatter });
    return { ...Object.fromEntries(dateValues), ...timeValues };
  }
  return Object.fromEntries(dateValues);
}
function initializeTimeSegmentValues(granularity) {
  return Object.fromEntries(
    TIME_SEGMENT_PARTS.map((part) => {
      if (part === "dayPeriod")
        return [part, "AM"];
      return [part, null];
    }).filter(([key]) => {
      if (key === "literal" || key === null)
        return false;
      if (granularity === "minute" && key === "second")
        return false;
      if (granularity === "hour" && (key === "second" || key === "minute"))
        return false;
      else return true;
    })
  );
}
function initializeSegmentValues(granularity) {
  const initialParts = EDITABLE_SEGMENT_PARTS.map((part) => {
    if (part === "dayPeriod")
      return [part, "AM"];
    return [part, null];
  }).filter(([key]) => {
    if (key === "literal" || key === null)
      return false;
    if (granularity === "minute" && key === "second")
      return false;
    if (granularity === "hour" && (key === "second" || key === "minute"))
      return false;
    if (granularity === "day")
      return !calendarDateTimeGranularities.includes(key) && key !== "dayPeriod";
    else return true;
  });
  return Object.fromEntries(initialParts);
}
function createContentObj(props) {
  const { segmentValues, formatter, locale } = props;
  function getPartContent(part) {
    if ("hour" in segmentValues) {
      const value = segmentValues[part];
      if (value !== null) {
        if (part === "day") {
          return formatter.part(props.dateRef.set({
            [part]: value,
            /**
             * Edge case for the day field:
             *
             * 1. If the month is filled,
             *   we need to ensure that the day snaps to the maximum value of that month.
             * 2. If the month is not filled,
             *   we default to the month with the maximum number of days (here just using January, 31 days),
             *   so that user can input any possible day.
             */
            month: segmentValues.month ?? 1
          }), part, { hourCycle: normalizeHourCycle(props.hourCycle) });
        }
        return formatter.part(props.dateRef.set({ [part]: value }), part, {
          hourCycle: normalizeHourCycle(props.hourCycle)
        });
      } else {
        return getPlaceholder(part, "", locale.value);
      }
    } else {
      if (isDateSegmentPart(part)) {
        const value = segmentValues[part];
        if (value !== null) {
          if (part === "day") {
            return formatter.part(props.dateRef.set({
              [part]: value,
              // Same logic as above for the day field
              month: segmentValues.month ?? 1
            }), part);
          }
          return formatter.part(props.dateRef.set({ [part]: value }), part);
        } else {
          return getPlaceholder(part, "", locale.value);
        }
      }
      return "";
    }
  }
  const content = Object.keys(segmentValues).reduce((obj, part) => {
    if (!isSegmentPart(part))
      return obj;
    if ("hour" in segmentValues && part === "dayPeriod") {
      const value = segmentValues[part];
      if (value !== null)
        obj[part] = value;
      else
        obj[part] = getPlaceholder(part, "AM", locale.value);
    } else {
      obj[part] = getPartContent(part);
    }
    return obj;
  }, {});
  return content;
}
function createContentArr(props) {
  const { granularity, formatter, contentObj, hideTimeZone, hourCycle, isTimeValue } = props;
  const parts = formatter.toParts(props.dateRef, getOptsByGranularity(granularity, hourCycle, isTimeValue));
  const segmentContentArr = parts.map((part) => {
    const defaultParts = ["literal", "timeZoneName", null];
    if (defaultParts.includes(part.type) || !isSegmentPart(part.type)) {
      return {
        part: part.type,
        value: part.value
      };
    }
    return {
      part: part.type,
      value: contentObj[part.type]
    };
  }).filter((segment) => {
    if (segment.part === null || segment.value === null)
      return false;
    if (segment.part === "timeZoneName" && (!isZonedDateTime(props.dateRef) || hideTimeZone))
      return false;
    return true;
  });
  return segmentContentArr;
}
function createContent(props) {
  const contentObj = createContentObj(props);
  const contentArr = createContentArr({
    contentObj,
    ...props
  });
  return {
    obj: contentObj,
    arr: contentArr
  };
}

export { initializeTimeSegmentValues as a, syncTimeSegmentValues as b, createContent as c, initializeSegmentValues as i, syncSegmentValues as s };
//# sourceMappingURL=parser.js.map