npm - @tenancy.nz/datepicker - Versions diffs - 1.3.4 - Mend

@tenancy.nz/datepicker 1.3.4

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.

Files changed (361) hide show

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/hooks/useReduceAnimations.js ADDED Viewed

@@ -0,0 +1,20 @@
+import useMediaQuery from '@mui/material/useMediaQuery';
+const PREFERS_REDUCED_MOTION = '@media (prefers-reduced-motion: reduce)';
+// detect if user agent has Android version < 10 or iOS version < 13
+const mobileVersionMatches = typeof navigator !== 'undefined' && navigator.userAgent.match(/android\s(\d+)|OS\s(\d+)/i);
+const androidVersion = mobileVersionMatches && mobileVersionMatches[1] ? parseInt(mobileVersionMatches[1], 10) : null;
+const iOSVersion = mobileVersionMatches && mobileVersionMatches[2] ? parseInt(mobileVersionMatches[2], 10) : null;
+const slowAnimationDevices = androidVersion && androidVersion < 10 || iOSVersion && iOSVersion < 13 || false;
+function useReduceAnimations(customReduceAnimations) {
+  const prefersReduced = useMediaQuery(PREFERS_REDUCED_MOTION, {
+    defaultMatches: false
+  });
+  if (customReduceAnimations != null) {
+    return customReduceAnimations;
+  }
+  return prefersReduced || slowAnimationDevices;
+}
+export { slowAnimationDevices, useReduceAnimations };

@@ -0,0 +1,16 @@
+import _extends from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import * as React from 'react';
+import { useRtl } from '../../../../../../../@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/RtlProvider/index.js';
+import { usePickerPrivateContext } from './usePickerPrivateContext.js';
+function useToolbarOwnerState() {
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext();
+  const isRtl = useRtl();
+  return React.useMemo(() => _extends({}, pickerOwnerState, {
+    toolbarDirection: isRtl ? 'rtl' : 'ltr'
+  }), [pickerOwnerState, isRtl]);
+}
+export { useToolbarOwnerState };

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { useLocalizationContext, usePickerAdapter } from '../../hooks/usePickerAdapter.js';
+const useDefaultDates = () => useLocalizationContext().defaultDates;
+const useNow = timezone => {
+  const adapter = usePickerAdapter();
+  const now = React.useRef(undefined);
+  if (now.current === undefined) {
+    now.current = adapter.date(undefined, timezone);
+  }
+  return now.current;
+};
+export { useDefaultDates, useNow };

@@ -0,0 +1,131 @@
+import _extends from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import * as React from 'react';
+import { DEFAULT_STEP_NAVIGATION } from '../utils/createStepNavigation.js';
+import useControlled from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useControlled/useControlled.js';
+import useEventCallback from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js';
+let warnedOnceNotValidView = false;
+function useViews({
+  onChange,
+  onViewChange,
+  openTo,
+  view: inView,
+  views,
+  autoFocus,
+  focusedView: inFocusedView,
+  onFocusedViewChange,
+  getStepNavigation
+}) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!warnedOnceNotValidView) {
+      if (inView != null && !views.includes(inView)) {
+        console.warn(`MUI X: \`view="${inView}"\` is not a valid prop.`, `It must be an element of \`views=["${views.join('", "')}"]\`.`);
+        warnedOnceNotValidView = true;
+      }
+      if (inView == null && openTo != null && !views.includes(openTo)) {
+        console.warn(`MUI X: \`openTo="${openTo}"\` is not a valid prop.`, `It must be an element of \`views=["${views.join('", "')}"]\`.`);
+        warnedOnceNotValidView = true;
+      }
+    }
+  }
+  const previousOpenTo = React.useRef(openTo);
+  const previousViews = React.useRef(views);
+  const defaultView = React.useRef(views.includes(openTo) ? openTo : views[0]);
+  const [view, setView] = useControlled({
+    name: 'useViews',
+    state: 'view',
+    controlled: inView,
+    default: defaultView.current
+  });
+  const defaultFocusedView = React.useRef(autoFocus ? view : null);
+  const [focusedView, setFocusedView] = useControlled({
+    name: 'useViews',
+    state: 'focusedView',
+    controlled: inFocusedView,
+    default: defaultFocusedView.current
+  });
+  const stepNavigation = getStepNavigation ? getStepNavigation({
+    setView,
+    view,
+    defaultView: defaultView.current,
+    views
+  }) : DEFAULT_STEP_NAVIGATION;
+  React.useEffect(() => {
+    // Update the current view when `openTo` or `views` props change
+    if (previousOpenTo.current && previousOpenTo.current !== openTo || previousViews.current && previousViews.current.some(previousView => !views.includes(previousView))) {
+      setView(views.includes(openTo) ? openTo : views[0]);
+      previousViews.current = views;
+      previousOpenTo.current = openTo;
+    }
+  }, [openTo, setView, view, views]);
+  const viewIndex = views.indexOf(view);
+  const previousView = views[viewIndex - 1] ?? null;
+  const nextView = views[viewIndex + 1] ?? null;
+  const handleFocusedViewChange = useEventCallback((viewToFocus, hasFocus) => {
+    if (hasFocus) {
+      // Focus event
+      setFocusedView(viewToFocus);
+    } else {
+      // Blur event
+      setFocusedView(prevFocusedView => viewToFocus === prevFocusedView ? null : prevFocusedView // If false the blur is due to view switching
+      );
+    }
+    onFocusedViewChange?.(viewToFocus, hasFocus);
+  });
+  const handleChangeView = useEventCallback(newView => {
+    // always keep the focused view in sync
+    handleFocusedViewChange(newView, true);
+    if (newView === view) {
+      return;
+    }
+    setView(newView);
+    if (onViewChange) {
+      onViewChange(newView);
+    }
+  });
+  const goToNextView = useEventCallback(() => {
+    if (nextView) {
+      handleChangeView(nextView);
+    }
+  });
+  const setValueAndGoToNextView = useEventCallback((value, currentViewSelectionState, selectedView) => {
+    const isSelectionFinishedOnCurrentView = currentViewSelectionState === 'finish';
+    const hasMoreViews = selectedView ?
+    // handles case like `DateTimePicker`, where a view might return a `finish` selection state
+    // but when it's not the final view given all `views` -> overall selection state should be `partial`.
+    views.indexOf(selectedView) < views.length - 1 : Boolean(nextView);
+    const globalSelectionState = isSelectionFinishedOnCurrentView && hasMoreViews ? 'partial' : currentViewSelectionState;
+    onChange(value, globalSelectionState, selectedView);
+    // The selected view can be different from the active view,
+    // This can happen if multiple views are displayed, like in `DesktopDateTimePicker` or `MultiSectionDigitalClock`.
+    let currentView = null;
+    if (selectedView != null && selectedView !== view) {
+      currentView = selectedView;
+    } else if (isSelectionFinishedOnCurrentView) {
+      currentView = view;
+    }
+    if (currentView == null) {
+      return;
+    }
+    const viewToNavigateTo = views[views.indexOf(currentView) + 1];
+    if (viewToNavigateTo == null || !stepNavigation.areViewsInSameStep(currentView, viewToNavigateTo)) {
+      return;
+    }
+    handleChangeView(viewToNavigateTo);
+  });
+  return _extends({}, stepNavigation, {
+    view,
+    setView: handleChangeView,
+    focusedView,
+    setFocusedView: handleFocusedViewChange,
+    nextView,
+    previousView,
+    // Always return up-to-date default view instead of the initial one (i.e. defaultView.current)
+    defaultView: views.includes(openTo) ? openTo : views[0],
+    goToNextView,
+    setValueAndGoToNextView
+  });
+}
+export { useViews };

@@ -0,0 +1,27 @@
+import { createStepNavigation } from './createStepNavigation.js';
+function createNonRangePickerStepNavigation(parameters) {
+  const {
+    steps
+  } = parameters;
+  return createStepNavigation({
+    steps,
+    isViewMatchingStep: (view, step) => {
+      return step.views == null || step.views.includes(view);
+    },
+    onStepChange: ({
+      step,
+      defaultView,
+      setView,
+      view,
+      views
+    }) => {
+      const targetView = step.views == null ? defaultView : step.views.find(viewBis => views.includes(viewBis));
+      if (targetView !== view) {
+        setView(targetView);
+      }
+    }
+  });
+}
+export { createNonRangePickerStepNavigation };

@@ -0,0 +1,47 @@
+import _extends from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+const DEFAULT_STEP_NAVIGATION = {
+  hasNextStep: false,
+  hasSeveralSteps: false,
+  goToNextStep: () => {},
+  areViewsInSameStep: () => true
+};
+/**
+ * Create an object that determines whether there is a next step and allows to go to the next step.
+ * @param {CreateStepNavigationParameters<TStep>} parameters The parameters of the createStepNavigation function
+ * @returns {CreateStepNavigationReturnValue} The return value of the createStepNavigation function
+ */
+function createStepNavigation(parameters) {
+  const {
+    steps,
+    isViewMatchingStep,
+    onStepChange
+  } = parameters;
+  return parametersBis => {
+    if (steps == null) {
+      return DEFAULT_STEP_NAVIGATION;
+    }
+    const currentStepIndex = steps.findIndex(step => isViewMatchingStep(parametersBis.view, step));
+    const nextStep = currentStepIndex === -1 || currentStepIndex === steps.length - 1 ? null : steps[currentStepIndex + 1];
+    return {
+      hasNextStep: nextStep != null,
+      hasSeveralSteps: steps.length > 1,
+      goToNextStep: () => {
+        if (nextStep == null) {
+          return;
+        }
+        onStepChange(_extends({}, parametersBis, {
+          step: nextStep
+        }));
+      },
+      areViewsInSameStep: (viewA, viewB) => {
+        const stepA = steps.find(step => isViewMatchingStep(viewA, step));
+        const stepB = steps.find(step => isViewMatchingStep(viewB, step));
+        return stepA === stepB;
+      }
+    };
+  };
+}
+export { DEFAULT_STEP_NAVIGATION, createStepNavigation };

@@ -0,0 +1,123 @@
+import { areViewsEqual } from './views.js';
+const mergeDateAndTime = (adapter, dateParam, timeParam) => {
+  let mergedDate = dateParam;
+  mergedDate = adapter.setHours(mergedDate, adapter.getHours(timeParam));
+  mergedDate = adapter.setMinutes(mergedDate, adapter.getMinutes(timeParam));
+  mergedDate = adapter.setSeconds(mergedDate, adapter.getSeconds(timeParam));
+  mergedDate = adapter.setMilliseconds(mergedDate, adapter.getMilliseconds(timeParam));
+  return mergedDate;
+};
+const findClosestEnabledDate = ({
+  date,
+  disableFuture,
+  disablePast,
+  maxDate,
+  minDate,
+  isDateDisabled,
+  adapter,
+  timezone
+}) => {
+  const today = mergeDateAndTime(adapter, adapter.date(undefined, timezone), date);
+  if (disablePast && adapter.isBefore(minDate, today)) {
+    minDate = today;
+  }
+  if (disableFuture && adapter.isAfter(maxDate, today)) {
+    maxDate = today;
+  }
+  let forward = date;
+  let backward = date;
+  if (adapter.isBefore(date, minDate)) {
+    forward = minDate;
+    backward = null;
+  }
+  if (adapter.isAfter(date, maxDate)) {
+    if (backward) {
+      backward = maxDate;
+    }
+    forward = null;
+  }
+  while (forward || backward) {
+    if (forward && adapter.isAfter(forward, maxDate)) {
+      forward = null;
+    }
+    if (backward && adapter.isBefore(backward, minDate)) {
+      backward = null;
+    }
+    if (forward) {
+      if (!isDateDisabled(forward)) {
+        return forward;
+      }
+      forward = adapter.addDays(forward, 1);
+    }
+    if (backward) {
+      if (!isDateDisabled(backward)) {
+        return backward;
+      }
+      backward = adapter.addDays(backward, -1);
+    }
+  }
+  return null;
+};
+const replaceInvalidDateByNull = (adapter, value) => !adapter.isValid(value) ? null : value;
+const applyDefaultDate = (adapter, value, defaultValue) => {
+  if (value == null || !adapter.isValid(value)) {
+    return defaultValue;
+  }
+  return value;
+};
+const areDatesEqual = (adapter, a, b) => {
+  if (!adapter.isValid(a) && a != null && !adapter.isValid(b) && b != null) {
+    return true;
+  }
+  return adapter.isEqual(a, b);
+};
+const getMonthsInYear = (adapter, year) => {
+  const firstMonth = adapter.startOfYear(year);
+  const months = [firstMonth];
+  while (months.length < 12) {
+    const prevMonth = months[months.length - 1];
+    months.push(adapter.addMonths(prevMonth, 1));
+  }
+  return months;
+};
+const getTodayDate = (adapter, timezone, valueType) => valueType === 'date' ? adapter.startOfDay(adapter.date(undefined, timezone)) : adapter.date(undefined, timezone);
+const DATE_VIEWS = ['year', 'month', 'day'];
+const isDatePickerView = view => DATE_VIEWS.includes(view);
+const resolveDateFormat = (adapter, {
+  format,
+  views
+}, isInToolbar) => {
+  if (format != null) {
+    return format;
+  }
+  const formats = adapter.formats;
+  if (areViewsEqual(views, ['year'])) {
+    return formats.year;
+  }
+  if (areViewsEqual(views, ['month'])) {
+    return formats.month;
+  }
+  if (areViewsEqual(views, ['day'])) {
+    return formats.dayOfMonth;
+  }
+  if (areViewsEqual(views, ['month', 'year'])) {
+    return `${formats.month} ${formats.year}`;
+  }
+  if (areViewsEqual(views, ['day', 'month'])) {
+    return `${formats.month} ${formats.dayOfMonth}`;
+  }
+  if (isInToolbar) {
+    // Little localization hack (Google is doing the same for android native pickers):
+    // For english localization it is convenient to include weekday into the date "Mon, Jun 1".
+    // For other locales using strings like "June 1", without weekday.
+    return /en/.test(adapter.getCurrentLocaleCode()) ? formats.normalDateWithWeekday : formats.normalDate;
+  }
+  return formats.keyboardDate;
+};
+const getWeekdays = (adapter, date) => {
+  const start = adapter.startOfWeek(date);
+  return [0, 1, 2, 3, 4, 5, 6].map(diff => adapter.addDays(start, diff));
+};
+export { DATE_VIEWS, applyDefaultDate, areDatesEqual, findClosestEnabledDate, getMonthsInYear, getTodayDate, getWeekdays, isDatePickerView, mergeDateAndTime, replaceInvalidDateByNull, resolveDateFormat };

@@ -0,0 +1,62 @@
+import { createIsAfterIgnoreDatePart } from './time-utils.js';
+import { getTodayDate, mergeDateAndTime } from './date-utils.js';
+const SECTION_TYPE_GRANULARITY = {
+  year: 1,
+  month: 2,
+  day: 3,
+  hours: 4,
+  minutes: 5,
+  seconds: 6,
+  milliseconds: 7
+};
+const getSectionTypeGranularity = sections => Math.max(...sections.map(section => SECTION_TYPE_GRANULARITY[section.type] ?? 1));
+const roundDate = (adapter, granularity, date) => {
+  if (granularity === SECTION_TYPE_GRANULARITY.year) {
+    return adapter.startOfYear(date);
+  }
+  if (granularity === SECTION_TYPE_GRANULARITY.month) {
+    return adapter.startOfMonth(date);
+  }
+  if (granularity === SECTION_TYPE_GRANULARITY.day) {
+    return adapter.startOfDay(date);
+  }
+  // We don't have startOfHour / startOfMinute / startOfSecond
+  let roundedDate = date;
+  if (granularity < SECTION_TYPE_GRANULARITY.minutes) {
+    roundedDate = adapter.setMinutes(roundedDate, 0);
+  }
+  if (granularity < SECTION_TYPE_GRANULARITY.seconds) {
+    roundedDate = adapter.setSeconds(roundedDate, 0);
+  }
+  if (granularity < SECTION_TYPE_GRANULARITY.milliseconds) {
+    roundedDate = adapter.setMilliseconds(roundedDate, 0);
+  }
+  return roundedDate;
+};
+const getDefaultReferenceDate = ({
+  props,
+  adapter,
+  granularity,
+  timezone,
+  getTodayDate: inGetTodayDate
+}) => {
+  let referenceDate = inGetTodayDate ? inGetTodayDate() : roundDate(adapter, granularity, getTodayDate(adapter, timezone));
+  if (props.minDate != null && adapter.isAfterDay(props.minDate, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.minDate);
+  }
+  if (props.maxDate != null && adapter.isBeforeDay(props.maxDate, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.maxDate);
+  }
+  const isAfter = createIsAfterIgnoreDatePart(props.disableIgnoringDatePartForTimeValidation ?? false, adapter);
+  if (props.minTime != null && isAfter(props.minTime, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.minTime : mergeDateAndTime(adapter, referenceDate, props.minTime));
+  }
+  if (props.maxTime != null && isAfter(referenceDate, props.maxTime)) {
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.maxTime : mergeDateAndTime(adapter, referenceDate, props.maxTime));
+  }
+  return referenceDate;
+};
+export { SECTION_TYPE_GRANULARITY, getDefaultReferenceDate, getSectionTypeGranularity };

@@ -0,0 +1,13 @@
+const EXPORTED_TIME_VIEWS = ['hours', 'minutes', 'seconds'];
+const isTimeView = view => EXPORTED_TIME_VIEWS.includes(view);
+const getSecondsInDay = (date, adapter) => {
+  return adapter.getHours(date) * 3600 + adapter.getMinutes(date) * 60 + adapter.getSeconds(date);
+};
+const createIsAfterIgnoreDatePart = (disableIgnoringDatePartForTimeValidation, adapter) => (dateLeft, dateRight) => {
+  if (disableIgnoringDatePartForTimeValidation) {
+    return adapter.isAfter(dateLeft, dateRight);
+  }
+  return getSecondsInDay(dateLeft, adapter) > getSecondsInDay(dateRight, adapter);
+};
+export { EXPORTED_TIME_VIEWS, createIsAfterIgnoreDatePart, getSecondsInDay, isTimeView };

@@ -0,0 +1,37 @@
+import ownerDocument from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js';
+/* Use it instead of .includes method for IE support */
+function arrayIncludes(array, itemOrItems) {
+  if (Array.isArray(itemOrItems)) {
+    return itemOrItems.every(item => array.indexOf(item) !== -1);
+  }
+  return array.indexOf(itemOrItems) !== -1;
+}
+const executeInTheNextEventLoopTick = fn => {
+  setTimeout(fn, 0);
+};
+// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
+const getActiveElementInternal = (root = document) => {
+  const activeEl = root.activeElement;
+  if (!activeEl) {
+    return null;
+  }
+  if (activeEl.shadowRoot) {
+    return getActiveElementInternal(activeEl.shadowRoot);
+  }
+  return activeEl;
+};
+/**
+ * Gets the currently active element within a given node's document.
+ * This function traverses shadow DOM if necessary.
+ * @param node - The node from which to get the active element.
+ * @returns The currently active element, or null if none is found.
+ */
+const getActiveElement = node => {
+  return getActiveElementInternal(ownerDocument(node));
+};
+const DEFAULT_DESKTOP_MODE_MEDIA_QUERY = '@media (pointer: fine)';
+export { DEFAULT_DESKTOP_MODE_MEDIA_QUERY, arrayIncludes, executeInTheNextEventLoopTick, getActiveElement };

@@ -0,0 +1,47 @@
+import _extends from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import _objectWithoutPropertiesLoose from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import { areDatesEqual, replaceInvalidDateByNull, getTodayDate } from './date-utils.js';
+import { getDefaultReferenceDate } from './getDefaultReferenceDate.js';
+import { createDateStrForV6InputFromSections, createDateStrForV7HiddenInputFromSections } from '../hooks/useField/useField.utils.js';
+const _excluded = ["value", "referenceDate"];
+const singleItemValueManager = {
+  emptyValue: null,
+  getTodayValue: getTodayDate,
+  getInitialReferenceValue: _ref => {
+    let {
+        value,
+        referenceDate
+      } = _ref,
+      params = _objectWithoutPropertiesLoose(_ref, _excluded);
+    if (params.adapter.isValid(value)) {
+      return value;
+    }
+    if (referenceDate != null) {
+      return referenceDate;
+    }
+    return getDefaultReferenceDate(params);
+  },
+  cleanValue: replaceInvalidDateByNull,
+  areValuesEqual: areDatesEqual,
+  isSameError: (a, b) => a === b,
+  hasError: error => error != null,
+  defaultErrorState: null,
+  getTimezone: (adapter, value) => adapter.isValid(value) ? adapter.getTimezone(value) : null,
+  setTimezone: (adapter, timezone, value) => value == null ? null : adapter.setTimezone(value, timezone)
+};
+const singleItemFieldValueManager = {
+  updateReferenceValue: (adapter, value, prevReferenceValue) => adapter.isValid(value) ? value : prevReferenceValue,
+  getSectionsFromValue: (date, getSectionsFromDate) => getSectionsFromDate(date),
+  getV7HiddenInputValueFromSections: createDateStrForV7HiddenInputFromSections,
+  getV6InputValueFromSections: createDateStrForV6InputFromSections,
+  parseValueStr: (valueStr, referenceValue, parseDate) => parseDate(valueStr.trim(), referenceValue),
+  getDateFromSection: value => value,
+  getDateSectionsFromValue: sections => sections,
+  updateDateInValue: (value, activeSection, activeDate) => activeDate,
+  clearDateSections: sections => sections.map(section => _extends({}, section, {
+    value: ''
+  }))
+};
+export { singleItemFieldValueManager, singleItemValueManager };

@@ -0,0 +1,30 @@
+const areViewsEqual = (views, expectedViews) => {
+  if (views.length !== expectedViews.length) {
+    return false;
+  }
+  return expectedViews.every(expectedView => views.includes(expectedView));
+};
+const applyDefaultViewProps = ({
+  openTo,
+  defaultOpenTo,
+  views,
+  defaultViews
+}) => {
+  const viewsWithDefault = views ?? defaultViews;
+  let openToWithDefault;
+  if (openTo != null) {
+    openToWithDefault = openTo;
+  } else if (viewsWithDefault.includes(defaultOpenTo)) {
+    openToWithDefault = defaultOpenTo;
+  } else if (viewsWithDefault.length > 0) {
+    openToWithDefault = viewsWithDefault[0];
+  } else {
+    throw new Error('MUI X: The `views` prop must contain at least one view.');
+  }
+  return {
+    views: viewsWithDefault,
+    openTo: openToWithDefault
+  };
+};
+export { applyDefaultViewProps, areViewsEqual };

@@ -0,0 +1,76 @@
+import { getPickersLocalization } from './utils/getPickersLocalization.js';
+// This object is not Partial<PickersLocaleText> because it is the default values
+const enUSPickers = {
+  // Calendar navigation
+  previousMonth: 'Previous month',
+  nextMonth: 'Next month',
+  // View navigation
+  openPreviousView: 'Open previous view',
+  openNextView: 'Open next view',
+  calendarViewSwitchingButtonAriaLabel: view => view === 'year' ? 'year view is open, switch to calendar view' : 'calendar view is open, switch to year view',
+  // DateRange labels
+  start: 'Start',
+  end: 'End',
+  startDate: 'Start date',
+  startTime: 'Start time',
+  endDate: 'End date',
+  endTime: 'End time',
+  // Action bar
+  cancelButtonLabel: 'Cancel',
+  clearButtonLabel: 'Clear',
+  okButtonLabel: 'OK',
+  todayButtonLabel: 'Today',
+  nextStepButtonLabel: 'Next',
+  // Toolbar titles
+  datePickerToolbarTitle: 'Select date',
+  dateTimePickerToolbarTitle: 'Select date & time',
+  timePickerToolbarTitle: 'Select time',
+  dateRangePickerToolbarTitle: 'Select date range',
+  timeRangePickerToolbarTitle: 'Select time range',
+  // Clock labels
+  clockLabelText: (view, formattedTime) => `Select ${view}. ${!formattedTime ? 'No time selected' : `Selected time is ${formattedTime}`}`,
+  hoursClockNumberText: hours => `${hours} hours`,
+  minutesClockNumberText: minutes => `${minutes} minutes`,
+  secondsClockNumberText: seconds => `${seconds} seconds`,
+  // Digital clock labels
+  selectViewText: view => `Select ${view}`,
+  // Calendar labels
+  calendarWeekNumberHeaderLabel: 'Week number',
+  calendarWeekNumberHeaderText: '#',
+  calendarWeekNumberAriaLabelText: weekNumber => `Week ${weekNumber}`,
+  calendarWeekNumberText: weekNumber => `${weekNumber}`,
+  // Open Picker labels
+  openDatePickerDialogue: formattedDate => formattedDate ? `Choose date, selected date is ${formattedDate}` : 'Choose date',
+  openTimePickerDialogue: formattedTime => formattedTime ? `Choose time, selected time is ${formattedTime}` : 'Choose time',
+  openRangePickerDialogue: formattedRange => formattedRange ? `Choose range, selected range is ${formattedRange}` : 'Choose range',
+  fieldClearLabel: 'Clear',
+  // Table labels
+  timeTableLabel: 'pick time',
+  dateTableLabel: 'pick date',
+  // Field section placeholders
+  fieldYearPlaceholder: params => 'Y'.repeat(params.digitAmount),
+  fieldMonthPlaceholder: params => params.contentType === 'letter' ? 'MMMM' : 'MM',
+  fieldDayPlaceholder: () => 'DD',
+  fieldWeekDayPlaceholder: params => params.contentType === 'letter' ? 'EEEE' : 'EE',
+  fieldHoursPlaceholder: () => 'hh',
+  fieldMinutesPlaceholder: () => 'mm',
+  fieldSecondsPlaceholder: () => 'ss',
+  fieldMeridiemPlaceholder: () => 'aa',
+  // View names
+  year: 'Year',
+  month: 'Month',
+  day: 'Day',
+  weekDay: 'Week day',
+  hours: 'Hours',
+  minutes: 'Minutes',
+  seconds: 'Seconds',
+  meridiem: 'Meridiem',
+  // Common
+  empty: 'Empty'
+};
+const DEFAULT_LOCALE = enUSPickers;
+getPickersLocalization(enUSPickers);
+export { DEFAULT_LOCALE };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/locales/utils/getPickersLocalization.js ADDED Viewed

@@ -0,0 +1,15 @@
+import _extends from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+const getPickersLocalization = pickersTranslations => {
+  return {
+    components: {
+      MuiLocalizationProvider: {
+        defaultProps: {
+          localeText: _extends({}, pickersTranslations)
+        }
+      }
+    }
+  };
+};
+export { getPickersLocalization };