@base-ui/react 1.3.0 → 1.4.0

package/tabs/root/TabsRoot.js

@@ -12,7 +12,6 @@ var _useIsoLayoutEffect = require("@base-ui/utils/useIsoLayoutEffect");
 var _useStableCallback = require("@base-ui/utils/useStableCallback");
 var _useRenderElement = require("../../utils/useRenderElement");
 var _CompositeList = require("../../composite/list/CompositeList");
-var _DirectionContext = require("../../direction-provider/DirectionContext");
 var _TabsRootContext = require("./TabsRootContext");
 var _stateAttributesMapping = require("./stateAttributesMapping");
 var _jsxRuntime = require("react/jsx-runtime");
@@ -30,9 +29,9 @@ const TabsRoot = exports.TabsRoot = /*#__PURE__*/React.forwardRef(function TabsR
     orientation = 'horizontal',
     render,
     value: valueProp,
+    style,
     ...elementProps
   } = componentProps;
-  const direction = (0, _DirectionContext.useDirection)();
 
   // Track whether the user explicitly provided a `defaultValue` prop.
   // Used to determine if we should honor a disabled tab selection.
@@ -47,14 +46,62 @@ const TabsRoot = exports.TabsRoot = /*#__PURE__*/React.forwardRef(function TabsR
   });
   const isControlled = valueProp !== undefined;
   const [tabMap, setTabMap] = React.useState(() => new Map());
-  const [tabActivationDirection, setTabActivationDirection] = React.useState('none');
+
+  // Used for activation direction detection via tab element positions.
+  const getTabElementBySelectedValue = React.useCallback(selectedValue => {
+    if (selectedValue === undefined) {
+      return null;
+    }
+    for (const [tabElement, tabMetadata] of tabMap.entries()) {
+      if (tabMetadata != null && selectedValue === (tabMetadata.value ?? tabMetadata.index)) {
+        return tabElement;
+      }
+    }
+    return null;
+  }, [tabMap]);
+  const [activationDirectionState, setActivationDirectionState] = React.useState(() => ({
+    previousValue: value,
+    tabActivationDirection: 'none'
+  }));
+  const {
+    previousValue,
+    tabActivationDirection: committedTabActivationDirection
+  } = activationDirectionState;
+  let tabActivationDirection = committedTabActivationDirection;
+  let directionComputationIncomplete = false;
+
+  // Compute activation direction during render when value changes so children see
+  // the correct direction on their very first render after the selection update.
+  // The previous value snapshot is stored in state and synced after commit.
+  // https://github.com/mui/base-ui/issues/3873
+  if (previousValue !== value) {
+    tabActivationDirection = computeActivationDirection(previousValue, value, orientation, tabMap);
+
+    // When a new tab is added and selected in the same controlled update,
+    // the tab element may not yet be registered in tabMap, so direction was
+    // computed from a value-based fallback. Keep the previous value snapshot
+    // stale so we re-compute from DOM positions once tabMap is up to date.
+    directionComputationIncomplete = previousValue != null && value != null && getTabElementBySelectedValue(value) == null;
+  }
+  const nextPreviousValue = directionComputationIncomplete ? previousValue : value;
+  const shouldSyncActivationDirectionState = previousValue !== nextPreviousValue || committedTabActivationDirection !== tabActivationDirection;
+  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
+    if (!shouldSyncActivationDirectionState) {
+      return;
+    }
+    setActivationDirectionState({
+      previousValue: nextPreviousValue,
+      tabActivationDirection
+    });
+  }, [nextPreviousValue, shouldSyncActivationDirectionState, tabActivationDirection]);
   const onValueChange = (0, _useStableCallback.useStableCallback)((newValue, eventDetails) => {
+    const activationDirection = computeActivationDirection(value, newValue, orientation, tabMap);
+    eventDetails.activationDirection = activationDirection;
     onValueChangeProp?.(newValue, eventDetails);
     if (eventDetails.isCanceled) {
       return;
     }
     setValue(newValue);
-    setTabActivationDirection(eventDetails.activationDirection);
   });
   const registerMountedTabPanel = (0, _useStableCallback.useStableCallback)((panelValue, panelId) => {
     setMountedTabPanels(prev => {
@@ -91,21 +138,7 @@ const TabsRoot = exports.TabsRoot = /*#__PURE__*/React.forwardRef(function TabsR
     }
     return undefined;
   }, [tabMap]);
-
-  // used in `useActivationDirectionDetector` for setting data-activation-direction
-  const getTabElementBySelectedValue = React.useCallback(selectedValue => {
-    if (selectedValue === undefined) {
-      return null;
-    }
-    for (const [tabElement, tabMetadata] of tabMap.entries()) {
-      if (tabMetadata != null && selectedValue === (tabMetadata.value ?? tabMetadata.index)) {
-        return tabElement;
-      }
-    }
-    return null;
-  }, [tabMap]);
   const tabsContextValue = React.useMemo(() => ({
-    direction,
     getTabElementBySelectedValue,
     getTabIdByPanelValue,
     getTabPanelIdByValue,
@@ -116,7 +149,7 @@ const TabsRoot = exports.TabsRoot = /*#__PURE__*/React.forwardRef(function TabsR
     unregisterMountedTabPanel,
     tabActivationDirection,
     value
-  }), [direction, getTabElementBySelectedValue, getTabIdByPanelValue, getTabPanelIdByValue, onValueChange, orientation, registerMountedTabPanel, setTabMap, unregisterMountedTabPanel, tabActivationDirection, value]);
+  }), [getTabElementBySelectedValue, getTabIdByPanelValue, getTabPanelIdByValue, onValueChange, orientation, registerMountedTabPanel, setTabMap, unregisterMountedTabPanel, tabActivationDirection, value]);
   const selectedTabMetadata = React.useMemo(() => {
     for (const tabMetadata of tabMap.values()) {
       if (tabMetadata != null && tabMetadata.value === value) {
@@ -159,8 +192,16 @@ const TabsRoot = exports.TabsRoot = /*#__PURE__*/React.forwardRef(function TabsR
       return;
     }
     setValue(fallbackValue);
-    setTabActivationDirection('none');
-  }, [defaultValueProp, firstEnabledTabValue, hasExplicitDefaultValueProp, isControlled, selectedTabMetadata, setTabActivationDirection, setValue, tabMap, value]);
+    setActivationDirectionState(prev => {
+      if (prev.tabActivationDirection === 'none') {
+        return prev;
+      }
+      return {
+        ...prev,
+        tabActivationDirection: 'none'
+      };
+    });
+  }, [defaultValueProp, firstEnabledTabValue, hasExplicitDefaultValueProp, isControlled, selectedTabMetadata, setValue, tabMap, value]);
   const state = {
     orientation,
     tabActivationDirection
@@ -179,4 +220,56 @@ const TabsRoot = exports.TabsRoot = /*#__PURE__*/React.forwardRef(function TabsR
     })
   });
 });
-if (process.env.NODE_ENV !== "production") TabsRoot.displayName = "TabsRoot";
+if (process.env.NODE_ENV !== "production") TabsRoot.displayName = "TabsRoot";
+function computeActivationDirection(oldValue, newValue, orientation, tabMap) {
+  if (oldValue == null || newValue == null) {
+    return 'none';
+  }
+  let oldTab = null;
+  let newTab = null;
+  for (const [tabElement, tabMetadata] of tabMap.entries()) {
+    if (tabMetadata == null) {
+      continue;
+    }
+    const tabValue = tabMetadata.value ?? tabMetadata.index;
+    if (oldValue === tabValue) {
+      oldTab = tabElement;
+    }
+    if (newValue === tabValue) {
+      newTab = tabElement;
+    }
+    if (oldTab != null && newTab != null) {
+      break;
+    }
+  }
+  if (oldTab == null || newTab == null) {
+    // Fallback for dynamic tabs: when a tab element isn't registered yet
+    // (e.g. added and selected in the same update), infer direction from
+    // the values themselves. Works for comparable types (numbers, strings).
+    if (oldTab !== newTab && (typeof oldValue === 'number' || typeof oldValue === 'string') && typeof oldValue === typeof newValue) {
+      if (orientation === 'horizontal') {
+        return newValue > oldValue ? 'right' : 'left';
+      }
+      return newValue > oldValue ? 'down' : 'up';
+    }
+    return 'none';
+  }
+  const oldRect = oldTab.getBoundingClientRect();
+  const newRect = newTab.getBoundingClientRect();
+  if (orientation === 'horizontal') {
+    if (newRect.left < oldRect.left) {
+      return 'left';
+    }
+    if (newRect.left > oldRect.left) {
+      return 'right';
+    }
+  } else {
+    if (newRect.top < oldRect.top) {
+      return 'up';
+    }
+    if (newRect.top > oldRect.top) {
+      return 'down';
+    }
+  }
+  return 'none';
+}

package/tabs/tab/TabsTab.js

@@ -33,6 +33,7 @@ const TabsTab = exports.TabsTab = /*#__PURE__*/React.forwardRef(function TabsTab
     value,
     id: idProp,
     nativeButton = true,
+    style,
     ...elementProps
   } = componentProps;
   const {

package/temporal-adapter-date-fns/TemporalAdapterDateFns.d.ts

@@ -0,0 +1,93 @@
+import { Locale as DateFnsLocale } from 'date-fns/locale';
+import { TemporalAdapterFormats, DateBuilderReturnType, TemporalTimezone, TemporalAdapter } from "../types/temporal/index.js";
+declare module '@base-ui/react/types/temporal' {
+  interface TemporalSupportedObjectLookup {
+    'date-fns': Date;
+  }
+}
+export declare class TemporalAdapterDateFns implements TemporalAdapter {
+  isTimezoneCompatible: boolean;
+  lib: string;
+  private locale;
+  formats: TemporalAdapterFormats;
+  escapedCharacters: {
+    start: string;
+    end: string;
+  };
+  constructor({
+    locale
+  }?: TemporalAdapterDateFns.ConstructorParameters);
+  now: (timezone: TemporalTimezone) => Date;
+  date: <T extends string | null>(value: T, timezone: TemporalTimezone) => DateBuilderReturnType<T>;
+  parse: (value: string, format: string, timezone: TemporalTimezone) => Date;
+  getTimezone: (value: Date) => string;
+  setTimezone: (value: Date, timezone: TemporalTimezone) => Date;
+  toJsDate: (value: Date) => Date;
+  getCurrentLocaleCode: () => string;
+  isValid: (value: Date | null) => value is Date;
+  format: (value: Date, formatKey: keyof TemporalAdapterFormats) => string;
+  formatByString: (value: Date, format: string) => string;
+  isEqual: (value: Date | null, comparing: Date | null) => boolean;
+  isSameYear: (value: Date, comparing: Date) => boolean;
+  isSameMonth: (value: Date, comparing: Date) => boolean;
+  isSameDay: (value: Date, comparing: Date) => boolean;
+  isSameHour: (value: Date, comparing: Date) => boolean;
+  isAfter: (value: Date, comparing: Date) => boolean;
+  isBefore: (value: Date, comparing: Date) => boolean;
+  isWithinRange: (value: Date, [start, end]: [Date, Date]) => boolean;
+  startOfYear: (value: Date) => Date;
+  startOfMonth: (value: Date) => Date;
+  startOfWeek: (value: Date) => Date;
+  startOfDay: (value: Date) => Date;
+  startOfHour: (value: Date) => Date;
+  startOfMinute: (value: Date) => Date;
+  startOfSecond: (value: Date) => Date;
+  endOfYear: (value: Date) => Date;
+  endOfMonth: (value: Date) => Date;
+  endOfWeek: (value: Date) => Date;
+  endOfDay: (value: Date) => Date;
+  endOfHour: (value: Date) => Date;
+  endOfMinute: (value: Date) => Date;
+  endOfSecond: (value: Date) => Date;
+  addYears: (value: Date, amount: number) => Date;
+  addMonths: (value: Date, amount: number) => Date;
+  addWeeks: (value: Date, amount: number) => Date;
+  addDays: (value: Date, amount: number) => Date;
+  addHours: (value: Date, amount: number) => Date;
+  addMinutes: (value: Date, amount: number) => Date;
+  addSeconds: (value: Date, amount: number) => Date;
+  addMilliseconds: (value: Date, amount: number) => Date;
+  getYear: (value: Date) => number;
+  getMonth: (value: Date) => number;
+  getDate: (value: Date) => number;
+  getHours: (value: Date) => number;
+  getMinutes: (value: Date) => number;
+  getSeconds: (value: Date) => number;
+  getMilliseconds: (value: Date) => number;
+  getTime: (value: Date) => number;
+  setYear: (value: Date, year: number) => Date;
+  setMonth: (value: Date, month: number) => Date;
+  setDate: (value: Date, date: number) => Date;
+  setHours: (value: Date, hours: number) => Date;
+  setMinutes: (value: Date, minutes: number) => Date;
+  setSeconds: (value: Date, seconds: number) => Date;
+  setMilliseconds: (value: Date, milliseconds: number) => Date;
+  differenceInYears: (value: Date, comparing: Date) => number;
+  differenceInMonths: (value: Date, comparing: Date) => number;
+  differenceInWeeks: (value: Date, comparing: Date) => number;
+  differenceInDays: (value: Date, comparing: Date) => number;
+  differenceInHours: (value: Date, comparing: Date) => number;
+  differenceInMinutes: (value: Date, comparing: Date) => number;
+  getDaysInMonth: (value: Date) => number;
+  getWeekNumber: (value: Date) => number;
+  getDayOfWeek: (value: Date) => number;
+}
+export declare namespace TemporalAdapterDateFns {
+  interface ConstructorParameters {
+    /**
+     * The locale to use for formatting and parsing dates.
+     * @default enUS
+     */
+    locale?: DateFnsLocale | undefined;
+  }
+}

package/temporal-adapter-date-fns/TemporalAdapterDateFns.js

@@ -0,0 +1,358 @@
+"use strict";
+'use client';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TemporalAdapterDateFns = void 0;
+var _addDays = require("date-fns/addDays");
+var _addHours = require("date-fns/addHours");
+var _addMinutes = require("date-fns/addMinutes");
+var _addMonths = require("date-fns/addMonths");
+var _addSeconds = require("date-fns/addSeconds");
+var _addMilliseconds = require("date-fns/addMilliseconds");
+var _addWeeks = require("date-fns/addWeeks");
+var _addYears = require("date-fns/addYears");
+var _differenceInDays = require("date-fns/differenceInDays");
+var _differenceInHours = require("date-fns/differenceInHours");
+var _differenceInMinutes = require("date-fns/differenceInMinutes");
+var _differenceInMonths = require("date-fns/differenceInMonths");
+var _differenceInWeeks = require("date-fns/differenceInWeeks");
+var _differenceInYears = require("date-fns/differenceInYears");
+var _endOfDay = require("date-fns/endOfDay");
+var _endOfHour = require("date-fns/endOfHour");
+var _endOfMinute = require("date-fns/endOfMinute");
+var _endOfMonth = require("date-fns/endOfMonth");
+var _endOfSecond = require("date-fns/endOfSecond");
+var _endOfWeek = require("date-fns/endOfWeek");
+var _endOfYear = require("date-fns/endOfYear");
+var _format = require("date-fns/format");
+var _getDate = require("date-fns/getDate");
+var _getDay = require("date-fns/getDay");
+var _getDaysInMonth = require("date-fns/getDaysInMonth");
+var _getHours = require("date-fns/getHours");
+var _getMilliseconds = require("date-fns/getMilliseconds");
+var _getMinutes = require("date-fns/getMinutes");
+var _getMonth = require("date-fns/getMonth");
+var _getSeconds = require("date-fns/getSeconds");
+var _getWeek = require("date-fns/getWeek");
+var _getYear = require("date-fns/getYear");
+var _isAfter = require("date-fns/isAfter");
+var _isBefore = require("date-fns/isBefore");
+var _isEqual = require("date-fns/isEqual");
+var _isSameDay = require("date-fns/isSameDay");
+var _isSameHour = require("date-fns/isSameHour");
+var _isSameYear = require("date-fns/isSameYear");
+var _isSameMonth = require("date-fns/isSameMonth");
+var _isValid = require("date-fns/isValid");
+var _isWithinInterval = require("date-fns/isWithinInterval");
+var _enUS = require("date-fns/locale/en-US");
+var _parse = require("date-fns/parse");
+var _setDate = require("date-fns/setDate");
+var _setHours = require("date-fns/setHours");
+var _setMilliseconds = require("date-fns/setMilliseconds");
+var _setMinutes = require("date-fns/setMinutes");
+var _setMonth = require("date-fns/setMonth");
+var _setSeconds = require("date-fns/setSeconds");
+var _setYear = require("date-fns/setYear");
+var _startOfDay = require("date-fns/startOfDay");
+var _startOfHour = require("date-fns/startOfHour");
+var _startOfMinute = require("date-fns/startOfMinute");
+var _startOfMonth = require("date-fns/startOfMonth");
+var _startOfSecond = require("date-fns/startOfSecond");
+var _startOfYear = require("date-fns/startOfYear");
+var _startOfWeek = require("date-fns/startOfWeek");
+var _tz = require("@date-fns/tz");
+const FORMATS = {
+  // Digit formats with leading zeroes
+  yearPadded: 'yyyy',
+  monthPadded: 'MM',
+  dayOfMonthPadded: 'dd',
+  hours24hPadded: 'HH',
+  hours12hPadded: 'hh',
+  minutesPadded: 'mm',
+  secondsPadded: 'ss',
+  // Digit formats without leading zeroes
+  dayOfMonth: 'd',
+  hours24h: 'H',
+  hours12h: 'h',
+  // Letter formats
+  month3Letters: 'MMM',
+  monthFullLetter: 'MMMM',
+  weekday: 'EEEE',
+  weekday3Letters: 'EEE',
+  weekday1Letter: 'EEEEE',
+  meridiem: 'a',
+  // Full formats
+  localizedDateWithFullMonthAndWeekDay: 'PPPP',
+  localizedNumericDate: 'P' // Note: Day and month are padded on enUS unlike Luxon
+};
+
+// TODO Temporal: Replace with `@base-ui/react/types` path when Temporal components will become public.
+
+class TemporalAdapterDateFns {
+  isTimezoneCompatible = true;
+  lib = 'date-fns';
+  formats = FORMATS;
+  escapedCharacters = {
+    start: "'",
+    end: "'"
+  };
+  constructor({
+    locale
+  } = {}) {
+    this.locale = locale ?? _enUS.enUS;
+  }
+  now = timezone => {
+    if (timezone === 'system' || timezone === 'default') {
+      return new Date();
+    }
+    return _tz.TZDate.tz(timezone);
+  };
+  date = (value, timezone) => {
+    if (value === null) {
+      return null;
+    }
+    const date = new Date(value);
+    if (timezone === 'system' || timezone === 'default') {
+      return date;
+    }
+
+    // `new TZDate(value, timezone)` returns a date with the same timestamp `new Date(value)` would return,
+    // whereas we want to create that represents the string in the given timezone.
+    return new _tz.TZDate(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds(), timezone);
+  };
+  parse = (value, format, timezone) => {
+    const date = (0, _parse.parse)(value, format, new Date(), {
+      locale: this.locale
+    });
+    if (timezone === 'system' || timezone === 'default') {
+      return date;
+    }
+
+    // `new TZDate(value, timezone)` returns a date with the same timestamp `new Date(value)` would return,
+    // whereas we want to create that represents the string in the given timezone.
+    return new _tz.TZDate(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds(), timezone);
+  };
+  getTimezone = value => {
+    if (value instanceof _tz.TZDate) {
+      return value.timeZone ?? 'system';
+    }
+    return 'system';
+  };
+  setTimezone = (value, timezone) => {
+    const isSystemTimezone = timezone === 'system' || timezone === 'default';
+    if (value instanceof _tz.TZDate) {
+      if (isSystemTimezone) {
+        return this.toJsDate(value);
+      }
+      return value.withTimeZone(timezone);
+    }
+    if (isSystemTimezone) {
+      return value;
+    }
+    return new _tz.TZDate(value, timezone);
+  };
+  toJsDate = value => {
+    if (value instanceof _tz.TZDate) {
+      return new Date(value.getTime());
+    }
+    return value;
+  };
+  getCurrentLocaleCode = () => {
+    return this.locale.code;
+  };
+  isValid = value => {
+    if (value == null) {
+      return false;
+    }
+    return (0, _isValid.isValid)(value);
+  };
+  format = (value, formatKey) => {
+    return this.formatByString(value, this.formats[formatKey]);
+  };
+  formatByString = (value, format) => {
+    return (0, _format.format)(value, format, {
+      locale: this.locale
+    });
+  };
+  isEqual = (value, comparing) => {
+    if (value === null && comparing === null) {
+      return true;
+    }
+    if (value === null || comparing === null) {
+      return false;
+    }
+    return (0, _isEqual.isEqual)(value, comparing);
+  };
+  isSameYear = (value, comparing) => {
+    return (0, _isSameYear.isSameYear)(value, comparing);
+  };
+  isSameMonth = (value, comparing) => {
+    return (0, _isSameMonth.isSameMonth)(value, comparing);
+  };
+  isSameDay = (value, comparing) => {
+    return (0, _isSameDay.isSameDay)(value, comparing);
+  };
+  isSameHour = (value, comparing) => {
+    return (0, _isSameHour.isSameHour)(value, comparing);
+  };
+  isAfter = (value, comparing) => {
+    return (0, _isAfter.isAfter)(value, comparing);
+  };
+  isBefore = (value, comparing) => {
+    return (0, _isBefore.isBefore)(value, comparing);
+  };
+  isWithinRange = (value, [start, end]) => {
+    return (0, _isWithinInterval.isWithinInterval)(value, {
+      start,
+      end
+    });
+  };
+  startOfYear = value => {
+    return (0, _startOfYear.startOfYear)(value);
+  };
+  startOfMonth = value => {
+    return (0, _startOfMonth.startOfMonth)(value);
+  };
+  startOfWeek = value => {
+    return (0, _startOfWeek.startOfWeek)(value, {
+      locale: this.locale
+    });
+  };
+  startOfDay = value => {
+    return (0, _startOfDay.startOfDay)(value);
+  };
+  startOfHour = value => {
+    return (0, _startOfHour.startOfHour)(value);
+  };
+  startOfMinute = value => {
+    return (0, _startOfMinute.startOfMinute)(value);
+  };
+  startOfSecond = value => {
+    return (0, _startOfSecond.startOfSecond)(value);
+  };
+  endOfYear = value => {
+    return (0, _endOfYear.endOfYear)(value);
+  };
+  endOfMonth = value => {
+    return (0, _endOfMonth.endOfMonth)(value);
+  };
+  endOfWeek = value => {
+    return (0, _endOfWeek.endOfWeek)(value, {
+      locale: this.locale
+    });
+  };
+  endOfDay = value => {
+    return (0, _endOfDay.endOfDay)(value);
+  };
+  endOfHour = value => {
+    return (0, _endOfHour.endOfHour)(value);
+  };
+  endOfMinute = value => {
+    return (0, _endOfMinute.endOfMinute)(value);
+  };
+  endOfSecond = value => {
+    return (0, _endOfSecond.endOfSecond)(value);
+  };
+  addYears = (value, amount) => {
+    return (0, _addYears.addYears)(value, amount);
+  };
+  addMonths = (value, amount) => {
+    return (0, _addMonths.addMonths)(value, amount);
+  };
+  addWeeks = (value, amount) => {
+    return (0, _addWeeks.addWeeks)(value, amount);
+  };
+  addDays = (value, amount) => {
+    return (0, _addDays.addDays)(value, amount);
+  };
+  addHours = (value, amount) => {
+    return (0, _addHours.addHours)(value, amount);
+  };
+  addMinutes = (value, amount) => {
+    return (0, _addMinutes.addMinutes)(value, amount);
+  };
+  addSeconds = (value, amount) => {
+    return (0, _addSeconds.addSeconds)(value, amount);
+  };
+  addMilliseconds = (value, amount) => {
+    return (0, _addMilliseconds.addMilliseconds)(value, amount);
+  };
+  getYear = value => {
+    return (0, _getYear.getYear)(value);
+  };
+  getMonth = value => {
+    return (0, _getMonth.getMonth)(value);
+  };
+  getDate = value => {
+    return (0, _getDate.getDate)(value);
+  };
+  getHours = value => {
+    return (0, _getHours.getHours)(value);
+  };
+  getMinutes = value => {
+    return (0, _getMinutes.getMinutes)(value);
+  };
+  getSeconds = value => {
+    return (0, _getSeconds.getSeconds)(value);
+  };
+  getMilliseconds = value => {
+    return (0, _getMilliseconds.getMilliseconds)(value);
+  };
+  getTime = value => {
+    return value.getTime();
+  };
+  setYear = (value, year) => {
+    return (0, _setYear.setYear)(value, year);
+  };
+  setMonth = (value, month) => {
+    return (0, _setMonth.setMonth)(value, month);
+  };
+  setDate = (value, date) => {
+    return (0, _setDate.setDate)(value, date);
+  };
+  setHours = (value, hours) => {
+    return (0, _setHours.setHours)(value, hours);
+  };
+  setMinutes = (value, minutes) => {
+    return (0, _setMinutes.setMinutes)(value, minutes);
+  };
+  setSeconds = (value, seconds) => {
+    return (0, _setSeconds.setSeconds)(value, seconds);
+  };
+  setMilliseconds = (value, milliseconds) => {
+    return (0, _setMilliseconds.setMilliseconds)(value, milliseconds);
+  };
+  differenceInYears = (value, comparing) => {
+    return (0, _differenceInYears.differenceInYears)(value, comparing);
+  };
+  differenceInMonths = (value, comparing) => {
+    return (0, _differenceInMonths.differenceInMonths)(value, comparing);
+  };
+  differenceInWeeks = (value, comparing) => {
+    return (0, _differenceInWeeks.differenceInWeeks)(value, comparing);
+  };
+  differenceInDays = (value, comparing) => {
+    return (0, _differenceInDays.differenceInDays)(value, comparing);
+  };
+  differenceInHours = (value, comparing) => {
+    return (0, _differenceInHours.differenceInHours)(value, comparing);
+  };
+  differenceInMinutes = (value, comparing) => {
+    return (0, _differenceInMinutes.differenceInMinutes)(value, comparing);
+  };
+  getDaysInMonth = value => {
+    return (0, _getDaysInMonth.getDaysInMonth)(value);
+  };
+  getWeekNumber = value => {
+    return (0, _getWeek.getWeek)(value, {
+      locale: this.locale
+    });
+  };
+  getDayOfWeek = value => {
+    const weekStartsOn = this.locale.options?.weekStartsOn ?? 0;
+    return ((0, _getDay.getDay)(value) + 7 - weekStartsOn) % 7 + 1;
+  };
+}
+exports.TemporalAdapterDateFns = TemporalAdapterDateFns;

package/temporal-adapter-date-fns/index.d.ts

@@ -0,0 +1 @@
+export { TemporalAdapterDateFns } from "./TemporalAdapterDateFns.js";

package/temporal-adapter-date-fns/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TemporalAdapterDateFns", {
+  enumerable: true,
+  get: function () {
+    return _TemporalAdapterDateFns.TemporalAdapterDateFns;
+  }
+});
+var _TemporalAdapterDateFns = require("./TemporalAdapterDateFns");