@dynatrace/strato-components 3.2.1 → 3.3.1

package/core/time/timeframeStore/createTimeframeStore.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createTimeframeStore_exports = {};
+__export(createTimeframeStore_exports, {
+  createTimeframeStore: () => createTimeframeStore
+});
+module.exports = __toCommonJS(createTimeframeStore_exports);
+var import_zustand = require("zustand");
+function createTimeframeStore(initialState, actions) {
+  return (0, import_zustand.create)()((set) => ({
+    ...initialState,
+    ...actions(set)
+  }));
+}

package/core/time/timeframeStore/dateTimePicker.types.d.ts

@@ -0,0 +1,43 @@
+import { RefObject } from 'react';
+import type { DateTimeInputRef } from '../../../forms/date-time-range-picker/types.js';
+import { FormControlWithOverlayRef } from '../../../forms/shared-types.js';
+import type { TimeValue } from '../../types/time.js';
+import type { TimeErrorKey } from '../shared.types.js';
+import type { CalendarTimeframeState, CalendarTimeframeStoreActions } from './calendar.types.js';
+/**
+ * State slice for the DateTimePicker component.
+ * Extends CalendarTimeframeState to inherit calendar state while adding
+ * picker-specific state for managing single date-time value input.
+ * @internal
+ */
+export type DateTimePickerValueStates = CalendarTimeframeState & {
+    /** The current date-time value being edited in the picker. */
+    dateTimePickerValue: TimeValue | null;
+    /** Ref to the DateTimeInput used for robust post-calendar focus handling. */
+    dateTimeInputRef: RefObject<DateTimeInputRef>;
+    /** Ref to the DateTimePicker for imperative access (open/close overlay, focus, validation). */
+    dateTimePickerRef: RefObject<FormControlWithOverlayRef<HTMLSpanElement>>;
+    /** Current validation error state specific to the picker (e.g., out of bounds). */
+    dateTimePickerError?: TimeErrorKey;
+    /** ISO Format depending on the current locale and precision. */
+    formatString?: string;
+};
+/**
+ * Actions slice for the DateTimePicker component.
+ * Extends CalendarTimeframeStoreActions to inherit calendar actions while adding
+ * picker-specific actions for updating the single date-time value.
+ * @internal
+ */
+export type DateTimePickerValueStoreActions = CalendarTimeframeStoreActions & {
+    /**
+     * Updates the picker value when user edits the input. Validates and syncs with calendar.
+     * @param value - The new date-time value as ISO string or null to clear.
+     */
+    setDateTimePickerValue: (value: TimeValue | string | null) => void;
+};
+/**
+ * Combined DateTimePicker store type (state + actions).
+ * Use this when consuming the full DateTimePicker store.
+ * @internal
+ */
+export type DateTimePickerValueStore = DateTimePickerValueStates & DateTimePickerValueStoreActions;

package/core/time/timeframeStore/dateTimePicker.types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateTimePicker_types_exports = {};
+module.exports = __toCommonJS(dateTimePicker_types_exports);

package/core/time/timeframeStore/dateTimeRangePicker.types.d.ts

@@ -0,0 +1,44 @@
+import { RefObject } from 'react';
+import type { DateTimeInputRef, DateTimeRangePickerRef } from '../../../forms/date-time-range-picker/types.js';
+import type { Timeframe } from '../../types/time.js';
+import type { TimeErrorKey, Precision } from '../shared.types.js';
+import type { CalendarTimeframeState, CalendarTimeframeStoreActions } from './calendar.types.js';
+/**
+ * State slice for the DateTimeRangePicker component.
+ * Extends CalendarTimeframeState to inherit calendar state while adding
+ * picker-specific state for managing the from/to date-time range inputs.
+ * @internal
+ */
+export type DateTimeRangePickerTimeframeStates = CalendarTimeframeState & {
+    /** Narrows the base precision to exclude 'day' — DateTimeRangePicker does not support day-only precision. */
+    precision?: Exclude<Precision, 'day'>;
+    /** The current timeframe value with from/to dates being edited in the picker inputs. */
+    dateTimeRangePickerTimeframe: Partial<Timeframe> | null;
+    /** Ref to the "from" input used for post-calendar focus handling. */
+    dateTimeFromRef: RefObject<DateTimeInputRef>;
+    /** Ref to the DateTimeRangePicker for imperative access (open/close overlay, focus, validation). */
+    dateTimeRangePickerRef: RefObject<DateTimeRangePickerRef>;
+    /** Current validation error state specific to the picker (e.g., invalid order, out of bounds). */
+    dateTimeRangePickerError?: TimeErrorKey;
+    /** ISO Format depending on the current locale and precision. */
+    formatString?: string;
+};
+/**
+ * Actions slice for the DateTimeRangePicker component.
+ * Extends CalendarTimeframeStoreActions to inherit calendar actions while adding
+ * picker-specific actions for updating the timeframe from user input.
+ * @internal
+ */
+export type DateTimeRangePickerTimeframeStoreActions = CalendarTimeframeStoreActions & {
+    /** Updates the picker timeframe when user edits the from/to inputs. Validates and syncs with calendar. */
+    setDateTimeRangePickerTimeframe: (value: Partial<{
+        from: string;
+        to: string;
+    }> | Partial<Timeframe> | null | undefined) => void;
+};
+/**
+ * Combined DateTimeRangePicker store type (state + actions).
+ * Use this when consuming the full DateTimeRangePicker store.
+ * @internal
+ */
+export type DateTimeRangePickerTimeframeStore = DateTimeRangePickerTimeframeStates & DateTimeRangePickerTimeframeStoreActions;

package/core/time/timeframeStore/dateTimeRangePicker.types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateTimeRangePicker_types_exports = {};
+module.exports = __toCommonJS(dateTimeRangePicker_types_exports);

package/core/time/timeframeStore/timeframeSelector.types.d.ts

@@ -0,0 +1,43 @@
+import { RefObject } from 'react';
+import type { TimeRangePickerRef } from '../../../forms/shared-types.js';
+import type { Timeframe } from '../../types/time.js';
+import type { TimeErrorKey } from '../shared.types.js';
+import type { DateTimeRangePickerTimeframeStates, DateTimeRangePickerTimeframeStoreActions } from './dateTimeRangePicker.types.js';
+/**
+ * State slice for the TimeframeSelector component.
+ * Extends DateTimeRangePickerTimeframeStates to inherit both calendar and picker state
+ * while adding selector-specific state for presets, previous values, and full-day detection.
+ * @internal
+ */
+export type TimeframeSelectorState = DateTimeRangePickerTimeframeStates & {
+    /** The committed timeframe value that will be emitted via onChange. */
+    timeframeSelectorTimeframe: Timeframe | null;
+    /** Ref to the TimeframeSelector for imperative access (focus, validation). */
+    timeframeSelectorRef: RefObject<TimeRangePickerRef>;
+    /** The timeframe, used to calculate the steps for the stepper buttons. */
+    referenceTimeframe: Timeframe | null;
+    /** Current validation error state for the selector (propagated from picker/calendar). */
+    timeframeSelectorError?: TimeErrorKey;
+    /** Whether the current timeframe spans full days (midnight to midnight), affects stepper and display formats. */
+    isFullDay?: boolean;
+};
+/**
+ * Actions slice for the TimeframeSelector component.
+ * Extends DateTimeRangePickerTimeframeStoreActions to inherit calendar and picker actions
+ * while adding selector-specific actions for committing values and managing presets.
+ * @internal
+ */
+export type TimeframeSelectorStoreActions = DateTimeRangePickerTimeframeStoreActions & {
+    /** Commits the timeframe value, triggers onChange callback, and closes the overlay. */
+    setTimeframeSelectorTimeframe: (value: Timeframe | null) => void;
+    /** Updates reference timeframe to the given value. */
+    setReferenceTimeframe: (value: Timeframe | null) => void;
+    /** Updates the internal stepper value to the given timeframe. */
+    setStepperValue: (value: Timeframe | null) => void;
+};
+/**
+ * Combined TimeframeSelector store type (state + actions).
+ * Use this when consuming the full TimeframeSelector store.
+ * @internal
+ */
+export type TimeframeSelectorStore = TimeframeSelectorState & TimeframeSelectorStoreActions;

package/core/time/timeframeStore/timeframeSelector.types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeframeSelector_types_exports = {};
+module.exports = __toCommonJS(timeframeSelector_types_exports);

package/core/time/timeframeStore/timeframeStoreProvider.d.ts

@@ -0,0 +1,30 @@
+import type { StoreApi } from 'zustand';
+import type { CalendarTimeframeStore } from './calendar.types.js';
+import type { DateTimePickerValueStore } from './dateTimePicker.types.js';
+import type { DateTimeRangePickerTimeframeStore } from './dateTimeRangePicker.types.js';
+import type { TimeframeSelectorStore } from './timeframeSelector.types.js';
+import { WithChildren } from '../../types/with-children.js';
+/** @internal */
+export declare const CalendarStoreCtx: import("react").Context<StoreApi<CalendarTimeframeStore> | null>;
+/** @internal */
+export declare const DateTimePickerStoreCtx: import("react").Context<StoreApi<DateTimePickerValueStore> | null>;
+/** @internal */
+export declare const DateTimeRangePickerStoreCtx: import("react").Context<StoreApi<DateTimeRangePickerTimeframeStore> | null>;
+/** @internal */
+export declare const TimeframeSelectorStoreCtx: import("react").Context<StoreApi<TimeframeSelectorStore> | null>;
+/** @internal */
+export declare function CalendarStoreProvider({ store, children, }: WithChildren & {
+    store: StoreApi<CalendarTimeframeStore>;
+}): import("react/jsx-runtime").JSX.Element;
+/** @internal */
+export declare function DateTimePickerStoreProvider({ store, children, }: WithChildren & {
+    store: StoreApi<DateTimePickerValueStore>;
+}): import("react/jsx-runtime").JSX.Element;
+/** @internal */
+export declare function DateTimeRangePickerStoreProvider({ store, children, }: WithChildren & {
+    store: StoreApi<DateTimeRangePickerTimeframeStore>;
+}): import("react/jsx-runtime").JSX.Element;
+/** @internal */
+export declare function TimeframeSelectorStoreProvider({ store, children, }: WithChildren & {
+    store: StoreApi<TimeframeSelectorStore>;
+}): import("react/jsx-runtime").JSX.Element;

package/core/time/timeframeStore/timeframeStoreProvider.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeframeStoreProvider_exports = {};
+__export(timeframeStoreProvider_exports, {
+  CalendarStoreCtx: () => CalendarStoreCtx,
+  CalendarStoreProvider: () => CalendarStoreProvider,
+  DateTimePickerStoreCtx: () => DateTimePickerStoreCtx,
+  DateTimePickerStoreProvider: () => DateTimePickerStoreProvider,
+  DateTimeRangePickerStoreCtx: () => DateTimeRangePickerStoreCtx,
+  DateTimeRangePickerStoreProvider: () => DateTimeRangePickerStoreProvider,
+  TimeframeSelectorStoreCtx: () => TimeframeSelectorStoreCtx,
+  TimeframeSelectorStoreProvider: () => TimeframeSelectorStoreProvider
+});
+module.exports = __toCommonJS(timeframeStoreProvider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+const CalendarStoreCtx = (0, import_react.createContext)(null);
+const DateTimePickerStoreCtx = (0, import_react.createContext)(null);
+const DateTimeRangePickerStoreCtx = (0, import_react.createContext)(null);
+const TimeframeSelectorStoreCtx = (0, import_react.createContext)(null);
+function CalendarStoreProvider({
+  store,
+  children
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CalendarStoreCtx.Provider, { value: store, children });
+}
+function DateTimePickerStoreProvider({
+  store,
+  children
+}) {
+  const calStore = store;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CalendarStoreCtx.Provider, { value: calStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DateTimePickerStoreCtx.Provider, { value: store, children }) });
+}
+function DateTimeRangePickerStoreProvider({
+  store,
+  children
+}) {
+  const calStore = store;
+  const dtpStore = store;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CalendarStoreCtx.Provider, { value: calStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DateTimePickerStoreCtx.Provider, { value: dtpStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DateTimeRangePickerStoreCtx.Provider, { value: store, children }) }) });
+}
+function TimeframeSelectorStoreProvider({
+  store,
+  children
+}) {
+  const calStore = store;
+  const dtpStore = store;
+  const dtrpStore = store;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CalendarStoreCtx.Provider, { value: calStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DateTimePickerStoreCtx.Provider, { value: dtpStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DateTimeRangePickerStoreCtx.Provider, { value: dtrpStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TimeframeSelectorStoreCtx.Provider, { value: store, children }) }) }) });
+}

package/core/time/timeframeStore/useTimeframeStore.d.ts

@@ -0,0 +1,12 @@
+import type { CalendarTimeframeStore } from './calendar.types.js';
+import type { DateTimePickerValueStore } from './dateTimePicker.types.js';
+import type { DateTimeRangePickerTimeframeStore } from './dateTimeRangePicker.types.js';
+import type { TimeframeSelectorStore } from './timeframeSelector.types.js';
+/** @internal */
+export declare function useCalendarStore<T>(selector: (state: CalendarTimeframeStore) => T): T;
+/** @internal */
+export declare function useDateTimePickerStore<T>(selector: (state: DateTimePickerValueStore) => T): T;
+/** @internal */
+export declare function useDateTimeRangePickerStore<T>(selector: (state: DateTimeRangePickerTimeframeStore) => T): T;
+/** @internal */
+export declare function useTimeframeSelectorStore<T>(selector: (state: TimeframeSelectorStore) => T): T;

package/core/time/timeframeStore/useTimeframeStore.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useTimeframeStore_exports = {};
+__export(useTimeframeStore_exports, {
+  useCalendarStore: () => useCalendarStore,
+  useDateTimePickerStore: () => useDateTimePickerStore,
+  useDateTimeRangePickerStore: () => useDateTimeRangePickerStore,
+  useTimeframeSelectorStore: () => useTimeframeSelectorStore
+});
+module.exports = __toCommonJS(useTimeframeStore_exports);
+var import_react = require("react");
+var import_zustand = require("zustand");
+var import_timeframeStoreProvider = require("./timeframeStoreProvider.js");
+function useCalendarStore(selector) {
+  const store = (0, import_react.useContext)(import_timeframeStoreProvider.CalendarStoreCtx);
+  if (!store) {
+    throw new Error(
+      "useCalendarStore must be used within a CalendarStoreProvider"
+    );
+  }
+  return (0, import_zustand.useStore)(store, selector);
+}
+function useDateTimePickerStore(selector) {
+  const store = (0, import_react.useContext)(import_timeframeStoreProvider.DateTimePickerStoreCtx);
+  if (!store) {
+    throw new Error(
+      "useDateTimePickerStore must be used within a DateTimePickerStoreProvider"
+    );
+  }
+  return (0, import_zustand.useStore)(store, selector);
+}
+function useDateTimeRangePickerStore(selector) {
+  const store = (0, import_react.useContext)(import_timeframeStoreProvider.DateTimeRangePickerStoreCtx);
+  if (!store) {
+    throw new Error(
+      "useDateTimeRangePickerStore must be used within a DateTimeRangePickerStoreProvider"
+    );
+  }
+  return (0, import_zustand.useStore)(store, selector);
+}
+function useTimeframeSelectorStore(selector) {
+  const store = (0, import_react.useContext)(import_timeframeStoreProvider.TimeframeSelectorStoreCtx);
+  if (!store) {
+    throw new Error(
+      "useTimeframeSelectorStore must be used within a TimeframeSelectorStoreProvider"
+    );
+  }
+  return (0, import_zustand.useStore)(store, selector);
+}

package/core/time/untilMidnight.d.ts

@@ -0,0 +1,4 @@
+/** @internal Number of milliseconds in one day */
+export declare const ONE_DAY_IN_MILLISECONDS: number;
+/** @internal */
+export declare function untilMidnight(isoString: string | undefined, relativeNow?: number): number;

package/core/time/untilMidnight.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var untilMidnight_exports = {};
+__export(untilMidnight_exports, {
+  ONE_DAY_IN_MILLISECONDS: () => ONE_DAY_IN_MILLISECONDS,
+  untilMidnight: () => untilMidnight
+});
+module.exports = __toCommonJS(untilMidnight_exports);
+var import_tz = require("@date-fns/tz");
+var import_units = require("@dynatrace-sdk/units");
+var import_user_preferences = require("@dynatrace-sdk/user-preferences");
+const ONE_DAY_IN_MILLISECONDS = 1e3 * 60 * 60 * 24;
+function untilMidnight(isoString, relativeNow) {
+  const timezone = (0, import_user_preferences.getTimezone)();
+  const date = new import_tz.TZDateMini(
+    (0, import_units.parseTimeAsTimeValue)(isoString, relativeNow)?.absoluteDate ?? "",
+    timezone
+  );
+  if (Number.isNaN(date.getTime())) {
+    return ONE_DAY_IN_MILLISECONDS;
+  }
+  const midnight = new import_tz.TZDateMini(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate() + 1,
+    timezone
+  );
+  return midnight.getTime() - date.getTime();
+}

package/{forms/forms-core/hooks → core/time}/useDateTimeMessages.d.ts

@@ -1,9 +1,10 @@
 import { type FormatDateOptions } from 'react-intl';
+import type { Precision } from './shared.types.js';
 type Options = {
     locale?: string;
     timeZone?: string;
     type?: 'datetime' | 'date' | 'time';
-    precision?: 'minutes' | 'seconds' | 'milliseconds';
+    precision?: Precision;
 };
 /**
  * Hook providing localized datetime format and placeholders for given locale and timezone. If no locale is specified, the user region  setting is used.
@@ -12,6 +13,7 @@ type Options = {
 export declare const useDateTimeMessages: (options?: Options) => {
     locale: string;
     timeZone: string | undefined;
+    formatDateToParts: (this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions) => Intl.DateTimeFormatPart[];
     parts: Intl.DateTimeFormatPart[];
     formatOptions: FormatDateOptions;
     formatString: string;

package/{forms/forms-core/hooks → core/time}/useDateTimeMessages.js

@@ -25,7 +25,7 @@ var import_tz = require("@date-fns/tz");
 var import_react = require("react");
 var import_react_intl = require("react-intl");
 var import_user_preferences = require("@dynatrace-sdk/user-preferences");
-var import_intl_cache = require("../../date-time-picker/utils/intl-cache.js");
+var import_intl_cache = require("../../forms/date-time-picker/utils/intl-cache.js");
 const useDateTimeMessages = (options) => {
   const {
     locale = (0, import_user_preferences.getRegionalFormat)(),
@@ -140,6 +140,7 @@ const useDateTimeMessages = (options) => {
   return {
     locale,
     timeZone,
+    formatDateToParts,
     parts,
     formatOptions,
     formatString,

package/core/time/useIntervalCallback.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Custom hook that executes a callback function at specified intervals.
+ * The first execution happens after `initialDelay`, and subsequent executions
+ * happen every `repeatInterval` milliseconds.
+ *
+ * @param callback - The function to execute at each interval.
+ * @param deps - Dependencies for updating the callback function.
+ * @param initialDelay - Initial delay before the first execution in milliseconds.
+ * @param repeatInterval - Interval between subsequent executions in milliseconds. If not provided it falls back to the initialDelay.
+ * @returns An object containing the latest value returned by the callback and the last updated timestamp.
+ * @internal
+ */
+export declare function useIntervalCallback<T>(callback: () => T, deps: any[], initialDelay: number, repeatInterval?: number): {
+    value: T | null;
+    lastUpdated: number | null;
+};

package/core/time/useIntervalCallback.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useIntervalCallback_exports = {};
+__export(useIntervalCallback_exports, {
+  useIntervalCallback: () => useIntervalCallback
+});
+module.exports = __toCommonJS(useIntervalCallback_exports);
+var import_tz = require("@date-fns/tz");
+var import_react = require("react");
+var import_user_preferences = require("@dynatrace-sdk/user-preferences");
+function useIntervalCallback(callback, deps, initialDelay, repeatInterval) {
+  const [rerenderToken, forceRerender] = (0, import_react.useReducer)(() => ({}), {});
+  const [lastUpdated, setLastUpdated] = (0, import_react.useState)(Date.now());
+  const timeoutId = (0, import_react.useRef)(null);
+  const intervalId = (0, import_react.useRef)(null);
+  const timezone = (0, import_user_preferences.getTimezone)();
+  const clearTimers = () => {
+    if (timeoutId.current) {
+      clearTimeout(timeoutId.current);
+    }
+    if (intervalId.current) {
+      clearInterval(intervalId.current);
+    }
+  };
+  const startInterval = () => {
+    intervalId.current = setInterval(() => {
+      forceRerender();
+      setLastUpdated(import_tz.TZDateMini.tz(timezone).getTime());
+    }, repeatInterval ?? initialDelay);
+  };
+  const startTimeout = () => {
+    timeoutId.current = setTimeout(() => {
+      forceRerender();
+      setLastUpdated(import_tz.TZDateMini.tz(timezone).getTime());
+      startInterval();
+    }, initialDelay);
+  };
+  (0, import_react.useEffect)(() => {
+    startTimeout();
+    return clearTimers;
+  }, [...deps]);
+  const value = (0, import_react.useMemo)(callback, [rerenderToken, ...deps]);
+  if (initialDelay <= 0 || repeatInterval && repeatInterval <= 0) {
+    clearTimers();
+    return { value: null, lastUpdated: null };
+  }
+  return { value, lastUpdated };
+}

package/core/time/useMinMax.d.ts

@@ -0,0 +1,32 @@
+import type { StoreApi } from 'zustand';
+import type { Precision } from './shared.types.js';
+import type { TimeValue } from '../types/time.js';
+/**
+ * Hook that keeps min and max TimeValues refreshed at midnight.
+ * Replaces the duplicated pair of `useIntervalCallback` calls for min/max
+ * found in Calendar, DateTimePicker, DateTimeRangePicker and TimeframeSelector.
+ * @internal
+ */
+export declare function useMinMax(propMin: string | undefined, propMax: string | undefined, precision?: Precision): {
+    min: TimeValue | null;
+    max: TimeValue | null;
+};
+/**
+ * Hook that syncs min/max prop changes into a zustand timeframe store.
+ *
+ * Replaces the duplicated pair of `useEffect` hooks (one for min, one for max)
+ * present in Calendar, DateTimePicker, DateTimeRangePicker and TimeframeSelector.
+ * Merges them into a single combined effect so that both bounds are always
+ * validated and committed together.
+ *
+ * The `applyChange` callback receives the current store state and the incoming
+ * min/max values. It should return only the error-field updates — min and max
+ * themselves are set automatically by the hook.
+ * Wrap `applyChange` in `useCallback` at the call site to keep the effect stable.
+ *
+ * @internal
+ */
+export declare function useMinMaxStoreSync<S extends {
+    min?: TimeValue | null;
+    max?: TimeValue | null;
+}>(store: StoreApi<S>, min: TimeValue | null, max: TimeValue | null, applyChange: (state: S, min: TimeValue | null, max: TimeValue | null) => Partial<S>): void;

package/core/time/useMinMax.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useMinMax_exports = {};
+__export(useMinMax_exports, {
+  useMinMax: () => useMinMax,
+  useMinMaxStoreSync: () => useMinMaxStoreSync
+});
+module.exports = __toCommonJS(useMinMax_exports);
+var import_react = require("react");
+var import_untilMidnight = require("./untilMidnight.js");
+var import_useIntervalCallback = require("./useIntervalCallback.js");
+var import_timeParser = require("../../forms/forms-core/time/timeParser.js");
+function useMinMax(propMin, propMax, precision) {
+  const { value: min } = (0, import_useIntervalCallback.useIntervalCallback)(
+    () => (0, import_timeParser.getTimeValue)(propMin, precision) ?? null,
+    [propMin, precision],
+    (0, import_untilMidnight.untilMidnight)(propMin),
+    import_untilMidnight.ONE_DAY_IN_MILLISECONDS
+  );
+  const { value: max } = (0, import_useIntervalCallback.useIntervalCallback)(
+    () => (0, import_timeParser.getTimeValue)(propMax, precision) ?? null,
+    [propMax, precision],
+    (0, import_untilMidnight.untilMidnight)(propMax),
+    import_untilMidnight.ONE_DAY_IN_MILLISECONDS
+  );
+  return { min: min ?? null, max: max ?? null };
+}
+function useMinMaxStoreSync(store, min, max, applyChange) {
+  (0, import_react.useEffect)(() => {
+    store.setState((state) => ({
+      ...state,
+      min,
+      max,
+      ...applyChange(state, min, max)
+    }));
+  }, [min, max, store, applyChange]);
+}