@esri/calcite-components 5.2.0-next.4 → 5.2.0-next.40

package/dist/chunks/math.js

@@ -3,7 +3,7 @@ const clamp = (value, min, max) => Math.max(min, Math.min(value, max));
 const decimalNumberRegex = new RegExp(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
 const decimalPlaces = (value) => {
   const match = ("" + value).match(decimalNumberRegex);
-  if (!match || parseInt(match[1]) === 0) {
+  if (!match || parseInt(match[1], 10) === 0) {
     return 0;
   }
   return Math.max(

package/dist/chunks/openCloseComponent.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { o as whenTransitionDone } from "./dom.js";
+import { p as whenTransitionDone } from "./dom.js";
 function isOpen(component) {
   return component[component.openProp || "open"];
 }

package/dist/chunks/resources.js

@@ -3,7 +3,6 @@ const CSS = {
   button: "button",
   buttonTextVisible: "button--text-visible",
   buttonCompact: "button--compact",
-  indicatorText: "indicator-text",
   iconContainer: "icon-container",
   slotContainer: "slot-container",
   slotContainerHidden: "slot-container--hidden",

package/dist/chunks/resources2.js

@@ -1,24 +1,20 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-const CSS = {
-  menu: "menu",
-  defaultTrigger: "default-trigger"
-};
-const idPrefix = "calcite-action-menu";
-const IDS = {
-  button: (id) => `${idPrefix}-${id}-menu-button`,
-  menu: (id) => `${idPrefix}-${id}-menu`,
-  action: (id, actionId) => `${idPrefix}-${id}-action-${actionId}`
-};
 const SLOTS = {
-  tooltip: "tooltip",
-  trigger: "trigger"
+  menuActions: "menu-actions",
+  menuTooltip: "menu-tooltip"
 };
 const ICONS = {
   menu: "ellipsis"
 };
+const CSS = {
+  container: "container"
+};
+function isActionGroup(el) {
+  return el?.tagName === "CALCITE-ACTION-GROUP";
+}
 export {
   CSS as C,
-  IDS as I,
+  ICONS as I,
   SLOTS as S,
-  ICONS as a
+  isActionGroup as i
 };

package/dist/chunks/resources3.js

@@ -1,20 +1,28 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+const CSS = {
+  menu: "menu",
+  defaultTrigger: "default-trigger"
+};
+const idPrefix = "calcite-action-menu";
+const IDS = {
+  button: (id) => `${idPrefix}-${id}-menu-button`,
+  menu: (id) => `${idPrefix}-${id}-menu`,
+  action: (id, actionId) => `${idPrefix}-${id}-action-${actionId}`
+};
 const SLOTS = {
-  menuActions: "menu-actions",
-  menuTooltip: "menu-tooltip"
+  tooltip: "tooltip",
+  trigger: "trigger"
 };
 const ICONS = {
   menu: "ellipsis"
 };
-const CSS = {
-  container: "container"
-};
-function isActionGroup(el) {
-  return el?.tagName === "CALCITE-ACTION-GROUP";
+function isActionMenu(el) {
+  return el?.tagName === "CALCITE-ACTION-MENU";
 }
 export {
   CSS as C,
-  ICONS as I,
+  IDS as I,
   SLOTS as S,
-  isActionGroup as i
+  ICONS as a,
+  isActionMenu as i
 };

package/dist/chunks/resources5.js

@@ -11,6 +11,7 @@ const CSS = {
   contentEnd: "content-end",
   contentStart: "content-start",
   description: "description",
+  hasSlottedContent: "has-slotted-content",
   header: "header",
   headerContainer: "header-container",
   headerHasContent: "header--has-content",
@@ -31,6 +32,7 @@ const SLOTS = {
   actionsEnd: "actions-end",
   contentEnd: "content-end",
   contentStart: "content-start",
+  children: "children",
   headerMenuActions: "header-menu-actions"
 };
 const ICONS = {

package/dist/chunks/responsive.js

@@ -9,7 +9,7 @@ const breakpoints = {
   }
 };
 function cssLengthToNumber(length) {
-  return parseInt(length);
+  return parseInt(length, 10);
 }
 export {
   breakpoints as b

package/dist/chunks/runtime.js

@@ -14,7 +14,8 @@ const CSS_UTILITY = {
   calciteAnimateInUp: "calcite-animate__in-up",
   calciteAnimateInDown: "calcite-animate__in-down",
   calciteAnimateInRight: "calcite-animate__in-right",
-  calciteAnimateInLeft: "calcite-animate__in-left"
+  calciteAnimateInLeft: "calcite-animate__in-left",
+  screenReaderText: "screen-reader-text"
 };
 const DEBOUNCE = {
   filter: 250,
@@ -60,9 +61,9 @@ function getConfig() {
   }
   return effectiveConfig;
 }
-const version = "5.2.0-next.4";
-const buildDate = "2026-06-18";
-const revision = "c1ba7618a";
+const version = "5.2.0-next.40";
+const buildDate = "2026-07-31";
+const revision = "41ae2ac65";
 function stampVersion() {
   const config = getConfig();
   if (config && config.version) {
@@ -85,7 +86,7 @@ if (!isServer) {
 if (process.env.NODE_ENV !== "test") {
   queueMicrotask(stampVersion);
 }
-const runtime = makeRuntime({ defaultAssetPath: "https://cdn.jsdelivr.net/npm/@esri/calcite-components@5.2.0-next.4/dist/cdn/", hydratedAttribute: "calcite-hydrated" });
+const runtime = makeRuntime({ defaultAssetPath: "https://cdn.jsdelivr.net/npm/@esri/calcite-components@5.2.0-next.40/dist/cdn/", hydratedAttribute: "calcite-hydrated" });
 const { customElement, getAssetPath, setAssetPath } = runtime;
 export {
   CSS_UTILITY as C,

package/dist/chunks/useFocusTrap.js

@@ -1,7 +1,7 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
 import { makeGenericController } from "@arcgis/lumina/controllers";
 import { createFocusTrap } from "focus-trap";
-import { t as tabbableOptions, i as focusElement } from "./dom.js";
+import { u as tabbableOptions, j as focusElement } from "./dom.js";
 import { a as getConfig } from "./runtime.js";
 function getEffectiveContainerElements(targetEl, { focusTrapOptions }, extraContainers) {
   if (!focusTrapOptions?.extraContainers && !extraContainers) {

package/dist/chunks/useForm.js

@@ -1,7 +1,7 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
 import { makeGenericController, bypassReadOnly } from "@arcgis/lumina/controllers";
 import { uncapitalize, kebabToPascal } from "@arcgis/toolkit/string";
-import { r as isCalciteFocusable } from "./dom.js";
+import { q as isCalciteFocusable } from "./dom.js";
 import "lit";
 const minMaxStepTypes = ["date", "datetime-local", "month", "number", "range", "time", "week"];
 const patternTypes = ["email", "password", "search", "tel", "text", "url"];
@@ -42,9 +42,10 @@ function validate({
 }) {
   if (!Array.isArray(value)) {
     if (component && input.type === "radio") {
-      let group = component.elementInternals.form?.elements[component.name];
-      if (group?.length > 0) {
-        group = Array.from(group).filter(
+      const item = component.elementInternals.form?.elements.namedItem(component.name);
+      if (item) {
+        const elements = "length" in item ? Array.from(item) : [item];
+        const group = elements.filter(
           (element) => element.tagName === component.el.tagName
         );
         const isRequired = group.some((radioTypeElement) => radioTypeElement.required);
@@ -240,9 +241,10 @@ const useForm = (options) => {
         () => {
           clearValidationMessage(component, validationMessage);
           if (inputDelegate?.type === "radio") {
-            let group = component.elementInternals.form?.elements[component.name];
-            if (group?.length > 0) {
-              group = Array.from(group).filter(
+            const item = component.elementInternals.form?.elements.namedItem(component.name);
+            if (item) {
+              const elements = "length" in item ? Array.from(item) : [item];
+              const group = elements.filter(
                 (element) => element.tagName === component.el.tagName
               );
               const others = group.filter((radioTypeElement) => radioTypeElement !== component.el);

package/dist/chunks/useInlineEditable.js

@@ -0,0 +1,53 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { safeClassMap } from "@arcgis/lumina";
+import { nothing, html } from "lit";
+import { ref } from "lit/directives/ref.js";
+const CSS = {
+  container: "inline-editable--container",
+  enableEditing: "enable-editing",
+  confirmChanges: "confirm-changes",
+  cancelEditing: "cancel-editing"
+};
+const InlineEditableControls = ({ cancelEditingLabel, confirmChangesLabel, editingEnabled, enableEditingLabel, enableEditingButtonRef, loading, onCancelEditing, onConfirmChanges, onEnableEditing, scale, showControls }) => html`<div class=${safeClassMap(CSS.container)}>${!editingEnabled && html`<calcite-action .ariaLabel=${enableEditingLabel} class=${safeClassMap(CSS.enableEditing)} icon=pencil @click=${onEnableEditing} .scale=${scale} .text=${enableEditingLabel} title=${enableEditingLabel ?? nothing} type=button ${ref(enableEditingButtonRef)}></calcite-action>` || ""}${showControls && [
+  html`<calcite-action .ariaLabel=${confirmChangesLabel} class=${safeClassMap(CSS.confirmChanges)} icon=check .loading=${loading} @click=${onConfirmChanges} .scale=${scale} .text=${confirmChangesLabel} title=${confirmChangesLabel ?? nothing} type=button></calcite-action>`,
+  html`<calcite-action .ariaLabel=${cancelEditingLabel} class=${safeClassMap(CSS.cancelEditing)} icon=x @click=${onCancelEditing} .scale=${scale} .text=${cancelEditingLabel} title=${cancelEditingLabel ?? nothing} type=button></calcite-action>`
+] || ""}</div>`;
+class UseInlineEditable {
+  constructor(options) {
+    this.options = options;
+    this.valuePriorToEditing = "";
+  }
+  enable() {
+    this.valuePriorToEditing = this.options.getValue();
+    this.options.setEditingEnabled(true);
+    requestAnimationFrame(() => {
+      this.options.setFocus();
+    });
+    this.options.emitEnableEditingChange();
+  }
+  disable() {
+    this.options.setEditingEnabled(false);
+  }
+  cancelEditing() {
+    this.options.setValue(this.valuePriorToEditing);
+    this.disable();
+    this.options.emitCancel();
+  }
+  async confirm(afterConfirm, setLoading) {
+    this.options.emitConfirm();
+    try {
+      if (afterConfirm) {
+        setLoading?.(true);
+        await afterConfirm();
+        this.disable();
+      }
+    } finally {
+      setLoading?.(false);
+    }
+  }
+}
+export {
+  CSS as C,
+  InlineEditableControls as I,
+  UseInlineEditable as U
+};

package/dist/chunks/useLabel.js

@@ -0,0 +1,150 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { makeGenericController } from "@arcgis/lumina/controllers";
+import { r as queryElementRoots, c as closestElementCrossShadowBoundary, t as isBefore } from "./dom.js";
+const useLabel = makeGenericController((component, controller) => {
+  controller.onConnected(() => {
+    connectLabel(component);
+  });
+  controller.onDisconnected(() => {
+    disconnectLabel(component);
+  });
+});
+const labelClickEvent = "calciteInternalLabelClick";
+const labelConnectedEvent = "calciteInternalLabelConnected";
+const labelDisconnectedEvent = "calciteInternalLabelDisconnected";
+const labelTagName = "calcite-label";
+const labelToLabelables = /* @__PURE__ */ new WeakMap();
+const onLabelClickMap = /* @__PURE__ */ new WeakMap();
+const onLabelConnectedMap = /* @__PURE__ */ new WeakMap();
+const onLabelDisconnectedMap = /* @__PURE__ */ new WeakMap();
+const unlabeledComponents = /* @__PURE__ */ new Set();
+const findLabelForComponent = (componentEl) => {
+  const { id } = componentEl;
+  const forLabel = id && queryElementRoots(componentEl, { selector: `${labelTagName}[for="${id}"]` });
+  if (forLabel) {
+    return forLabel;
+  }
+  const parentLabel = closestElementCrossShadowBoundary(componentEl, labelTagName);
+  if (!parentLabel || // labelable components within other custom elements are not considered labelable
+  hasAncestorCustomElements(parentLabel, componentEl)) {
+    return null;
+  }
+  return parentLabel;
+};
+function hasAncestorCustomElements(label, componentEl) {
+  let traversedElements;
+  const customElementAncestorCheckEventType = "custom-element-ancestor-check";
+  const listener = ((event) => {
+    event.stopImmediatePropagation();
+    const composedPath = event.composedPath();
+    traversedElements = composedPath.slice(composedPath.indexOf(componentEl), composedPath.indexOf(label));
+  });
+  label.addEventListener(customElementAncestorCheckEventType, listener, { once: true });
+  componentEl.dispatchEvent(new CustomEvent(customElementAncestorCheckEventType, { composed: true, bubbles: true }));
+  label.removeEventListener(customElementAncestorCheckEventType, listener);
+  const ancestorCustomElements = traversedElements.filter((el) => el !== componentEl && el !== label).filter((el) => el.tagName?.includes("-"));
+  return ancestorCustomElements.length > 0;
+}
+function connectLabel(component) {
+  if (!component) {
+    return;
+  }
+  const labelEl = findLabelForComponent(component.el);
+  if (labelEl && onLabelClickMap.has(labelEl) && labelEl === component.labelEl || !labelEl && unlabeledComponents.has(component)) {
+    return;
+  }
+  const boundOnLabelDisconnected = onLabelDisconnected.bind(component);
+  if (labelEl) {
+    component.labelEl = labelEl;
+    const labelables = labelToLabelables.get(labelEl) || [];
+    labelables.push(component);
+    labelToLabelables.set(labelEl, labelables.sort(sortByDOMOrder));
+    if (!onLabelClickMap.has(component.labelEl)) {
+      onLabelClickMap.set(component.labelEl, onLabelClick);
+      component.labelEl.addEventListener(labelClickEvent, onLabelClick);
+    }
+    unlabeledComponents.delete(component);
+    document.removeEventListener(labelConnectedEvent, onLabelConnectedMap.get(component));
+    onLabelDisconnectedMap.set(component, boundOnLabelDisconnected);
+    document.addEventListener(labelDisconnectedEvent, boundOnLabelDisconnected);
+  } else if (!unlabeledComponents.has(component)) {
+    boundOnLabelDisconnected();
+    document.removeEventListener(labelDisconnectedEvent, onLabelDisconnectedMap.get(component));
+  }
+}
+function disconnectLabel(component) {
+  if (!component) {
+    return;
+  }
+  unlabeledComponents.delete(component);
+  document.removeEventListener(labelConnectedEvent, onLabelConnectedMap.get(component));
+  document.removeEventListener(labelDisconnectedEvent, onLabelDisconnectedMap.get(component));
+  onLabelConnectedMap.delete(component);
+  onLabelDisconnectedMap.delete(component);
+  if (!component.labelEl) {
+    return;
+  }
+  const labelables = labelToLabelables.get(component.labelEl);
+  if (labelables.length === 1) {
+    component.labelEl.removeEventListener(labelClickEvent, onLabelClickMap.get(component.labelEl));
+    onLabelClickMap.delete(component.labelEl);
+  }
+  labelToLabelables.set(
+    component.labelEl,
+    labelables.filter((labelable) => labelable !== component).sort(sortByDOMOrder)
+  );
+  component.labelEl = void 0;
+}
+function sortByDOMOrder(a, b) {
+  return isBefore(a.el, b.el) ? -1 : 1;
+}
+function onLabelClick(event) {
+  const labelClickTarget = event.detail.sourceEvent.target;
+  const labelables = labelToLabelables.get(this);
+  const clickedLabelable = labelables.find((labelable) => labelable.el === labelClickTarget);
+  const labelableChildClicked = clickedLabelable && labelables.includes(clickedLabelable);
+  if (labelableChildClicked) {
+    return;
+  }
+  const firstLabelable = labelables[0];
+  if (firstLabelable.disabled) {
+    return;
+  }
+  firstLabelable.onLabelClick(event);
+}
+function onLabelConnected() {
+  if (unlabeledComponents.has(this)) {
+    connectLabel(this);
+  }
+}
+function onLabelDisconnected() {
+  unlabeledComponents.add(this);
+  const boundOnLabelConnected = onLabelConnectedMap.get(this) || onLabelConnected.bind(this);
+  onLabelConnectedMap.set(this, boundOnLabelConnected);
+  document.addEventListener(labelConnectedEvent, boundOnLabelConnected);
+}
+async function associateExplicitLabelToUnlabeledComponent(label) {
+  await label.componentOnReady();
+  const alreadyLabeled = labelToLabelables.has(label);
+  if (alreadyLabeled) {
+    return;
+  }
+  const forComponentEl = label.for && label.ownerDocument?.getElementById(label.for);
+  if (!forComponentEl) {
+    return;
+  }
+  requestAnimationFrame(() => {
+    for (const labelable of unlabeledComponents) {
+      if (labelable.el === forComponentEl) {
+        connectLabel(labelable);
+        break;
+      }
+    }
+  });
+}
+export {
+  associateExplicitLabelToUnlabeledComponent as a,
+  labelDisconnectedEvent as b,
+  labelConnectedEvent as l,
+  useLabel as u
+};

package/dist/chunks/useSetFocus.js

@@ -1,7 +1,7 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
 import { makeGenericController } from "@arcgis/lumina/controllers";
 import { c as componentFocusable } from "./component.js";
-import { e as getRootNode, i as focusElement } from "./dom.js";
+import { h as getRootNode, j as focusElement } from "./dom.js";
 const useSetFocus = () => {
   return makeGenericController((component, controller) => {
     let abortController;

package/dist/chunks/useSortable.js

@@ -15,12 +15,36 @@ function onGlobalDragEnd() {
   Array.from(sortableComponentSet).forEach((component) => component.onGlobalDragEnd());
 }
 const globalDragState = { active: false };
+const activeSortableComponentSet = /* @__PURE__ */ new Set();
+function syncGlobalDragState() {
+  const active = activeSortableComponentSet.size > 0;
+  if (globalDragState.active === active) {
+    return;
+  }
+  globalDragState.active = active;
+  if (active) {
+    onGlobalDragStart();
+    return;
+  }
+  onGlobalDragEnd();
+}
+function markDragActive(component) {
+  activeSortableComponentSet.add(component);
+  syncGlobalDragState();
+}
+function markDragInactive(component) {
+  activeSortableComponentSet.delete(component);
+  syncGlobalDragState();
+}
 function createSortable(component) {
   const dataIdAttr = "id";
   const { el, group, handleSelector: handle, dragSelector: draggable, sortDisabled } = component;
   return Sortable.create(el, {
     dataIdAttr,
     swapThreshold: 0.5,
+    // Keep the fallback ghost out of nested list DOM updates during touch drag startup.
+    // Applied globally so all sortable hosts use the same stable fallback behavior.
+    fallbackOnBody: true,
     ...CSS,
     ...!!draggable && { draggable },
     ...!!group && {
@@ -59,14 +83,18 @@ function createSortable(component) {
     },
     handle,
     filter: `${handle}[disabled]`,
+    onChoose: () => {
+      markDragActive(component);
+    },
+    onUnchoose: () => {
+      markDragInactive(component);
+    },
     onStart: ({ from: fromEl, item: dragEl, to: toEl, newDraggableIndex: newIndex, oldDraggableIndex: oldIndex }) => {
-      globalDragState.active = true;
-      onGlobalDragStart();
+      markDragActive(component);
       component.onDragStart({ fromEl, dragEl, toEl, newIndex, oldIndex });
     },
     onEnd: ({ from: fromEl, item: dragEl, to: toEl, newDraggableIndex: newIndex, oldDraggableIndex: oldIndex }) => {
-      globalDragState.active = false;
-      onGlobalDragEnd();
+      markDragInactive(component);
       component.onDragEnd({ fromEl, dragEl, toEl, newIndex, oldIndex });
     },
     onSort: ({ from: fromEl, item: dragEl, to: toEl, newDraggableIndex: newIndex, oldDraggableIndex: oldIndex }) => {
@@ -103,6 +131,8 @@ const useSortable = () => {
       setUpSortable(component);
     });
     controller.onDisconnected(() => {
+      sortableComponentSet.delete(component);
+      markDragInactive(component);
       tearDownSortable(component);
     });
     return {

package/dist/chunks/useTime.js

@@ -55,9 +55,10 @@ function formatTimePart(number, minLength) {
   if (number >= 10) {
     return numberAsString;
   }
+  return;
 }
 function fractionalSecondPartToMilliseconds(fractionalSecondPart) {
-  return parseInt((parseFloat(`0.${fractionalSecondPart}`) / 1e-3).toFixed(3));
+  return parseInt((parseFloat(`0.${fractionalSecondPart}`) / 1e-3).toFixed(3), 10);
 }
 function getLocaleHourFormat(locale) {
   const options = { locale };
@@ -166,7 +167,7 @@ function getMeridiem(hour) {
   if (!isValidNumber(hour)) {
     return null;
   }
-  const hourAsNumber = parseInt(hour);
+  const hourAsNumber = parseInt(hour, 10);
   return hourAsNumber >= 0 && hourAsNumber <= 11 ? "AM" : "PM";
 }
 function getMeridiemOrder(locale) {
@@ -195,9 +196,9 @@ function isValidTime(value) {
   if (!hour || !minute) {
     return false;
   }
-  const hourAsNumber = parseInt(hour);
-  const minuteAsNumber = parseInt(minute);
-  const secondAsNumber = parseInt(second ?? "");
+  const hourAsNumber = parseInt(hour, 10);
+  const minuteAsNumber = parseInt(minute, 10);
+  const secondAsNumber = parseInt(second ?? "", 10);
   const hourValid = isValidNumber(hour) && hourAsNumber >= 0 && hourAsNumber < 24;
   const minuteValid = isValidNumber(minute) && minuteAsNumber >= 0 && minuteAsNumber < 60;
   const secondValid = isValidNumber(second) && secondAsNumber >= 0 && secondAsNumber < 60;
@@ -243,7 +244,7 @@ function localizeTimePart({
         numberingSystem
       };
       const localizedZero = numberStringFormatter.localize("0");
-      if (parseInt(value) === 0) {
+      if (parseInt(value, 10) === 0) {
         localizedFractionalSecond = "".padStart(value.length, localizedZero);
       } else {
         localizedFractionalSecond = numberStringFormatter.localize(`0.${value}`).replace(`${localizedZero}${localizedDecimalSeparator}`, "");
@@ -254,7 +255,7 @@ function localizeTimePart({
     }
     return localizedFractionalSecond;
   }
-  const valueAsNumber = parseInt(value);
+  const valueAsNumber = parseInt(value, 10);
   const date = new Date(
     Date.UTC(
       0,
@@ -291,9 +292,9 @@ function localizeTimeString({
       0,
       0,
       0,
-      parseInt(hour),
-      parseInt(minute),
-      includeSeconds && typeof second === "string" ? parseInt(second) : 0,
+      parseInt(hour, 10),
+      parseInt(minute, 10),
+      includeSeconds && typeof second === "string" ? parseInt(second, 10) : 0,
       includeSeconds && fractionalSecond ? fractionalSecondPartToMilliseconds(fractionalSecond) : 0
     )
   );
@@ -381,9 +382,9 @@ function toISOTimeString(value, step = 60) {
     fractionalSecond = value.fractionalSecond;
   }
   if (hour && minute) {
-    isoTimeString = `${formatTimePart(parseInt(hour))}:${formatTimePart(parseInt(minute))}`;
+    isoTimeString = `${formatTimePart(parseInt(hour, 10))}:${formatTimePart(parseInt(minute, 10))}`;
     if (step < 60) {
-      isoTimeString += `:${formatTimePart(parseInt(second || "0"))}`;
+      isoTimeString += `:${formatTimePart(parseInt(second || "0", 10))}`;
       if (step < 1) {
         isoTimeString += `.${formatFractionalSecond(fractionalSecond || "0", step)}`;
       }
@@ -399,7 +400,7 @@ class TimeController extends GenericController {
     this.handleHourKeyDownEvent = (event) => {
       const key = event.key;
       if (numberKeys.includes(key)) {
-        const keyAsNumber = parseInt(key);
+        const keyAsNumber = parseInt(key, 10);
         let newHour;
         if (isValidNumber(this.hour)) {
           switch (this.hourFormat) {
@@ -445,10 +446,10 @@ class TimeController extends GenericController {
     this.handleMinuteKeyDownEvent = (event) => {
       const key = event.key;
       if (numberKeys.includes(key)) {
-        const keyAsNumber = parseInt(key);
+        const keyAsNumber = parseInt(key, 10);
         let newMinute;
         if (typeof this.minute === "string" && isValidNumber(this.minute) && this.minute.startsWith("0")) {
-          const minuteAsNumber = parseInt(this.minute);
+          const minuteAsNumber = parseInt(this.minute, 10);
           newMinute = minuteAsNumber > maxTenthForMinuteAndSecond ? keyAsNumber : `${minuteAsNumber}${keyAsNumber}`;
         } else {
           newMinute = keyAsNumber;
@@ -479,10 +480,10 @@ class TimeController extends GenericController {
     this.handleSecondKeyDownEvent = (event) => {
       const key = event.key;
       if (numberKeys.includes(key)) {
-        const keyAsNumber = parseInt(key);
+        const keyAsNumber = parseInt(key, 10);
         let newSecond;
         if (typeof this.second === "string" && isValidNumber(this.second) && this.second.startsWith("0")) {
-          const secondAsNumber = parseInt(this.second);
+          const secondAsNumber = parseInt(this.second, 10);
           newSecond = secondAsNumber > maxTenthForMinuteAndSecond ? keyAsNumber : `${secondAsNumber}${keyAsNumber}`;
         } else {
           newSecond = keyAsNumber;
@@ -514,7 +515,7 @@ class TimeController extends GenericController {
       const { key } = event;
       if (numberKeys.includes(key)) {
         const stepPrecision = decimalPlaces(this.component.step);
-        const fractionalSecondAsInteger = parseInt(this.fractionalSecond);
+        const fractionalSecondAsInteger = parseInt(this.fractionalSecond, 10);
         const fractionalSecondAsIntegerLength = fractionalSecondAsInteger.toString().length;
         let newFractionalSecondAsIntegerString;
         if (fractionalSecondAsIntegerLength >= stepPrecision) {
@@ -579,7 +580,7 @@ class TimeController extends GenericController {
   //#endregion
   //#region Public Methods
   decrementHour() {
-    const newHour = !this.hour ? 0 : this.hour === "00" ? 23 : parseInt(this.hour) - 1;
+    const newHour = !this.hour ? 0 : this.hour === "00" ? 23 : parseInt(this.hour, 10) - 1;
     this.setValuePart("hour", newHour);
   }
   decrementMinute() {
@@ -589,7 +590,7 @@ class TimeController extends GenericController {
     this.decrementMinuteOrSecond("second");
   }
   incrementHour() {
-    const newHour = typeof this.hour === "string" && isValidNumber(this.hour) ? this.hour === "23" ? 0 : parseInt(this.hour) + 1 : 1;
+    const newHour = typeof this.hour === "string" && isValidNumber(this.hour) ? this.hour === "23" ? 0 : parseInt(this.hour, 10) + 1 : 1;
     this.setValuePart("hour", newHour);
   }
   incrementMinute() {
@@ -601,7 +602,7 @@ class TimeController extends GenericController {
   nudgeFractionalSecond(direction) {
     const stepDecimal = getDecimals(this.component.step);
     const stepPrecision = decimalPlaces(this.component.step);
-    const fractionalSecondAsInteger = parseInt(this.fractionalSecond);
+    const fractionalSecondAsInteger = parseInt(this.fractionalSecond, 10);
     const fractionalSecondAsFloat = parseFloat(`0.${this.fractionalSecond}`);
     let nudgedValue;
     let nudgedValueRounded;
@@ -674,7 +675,7 @@ class TimeController extends GenericController {
   decrementMinuteOrSecond(key) {
     let newValue;
     if (isValidNumber(this[key])) {
-      const valueAsNumber = parseInt(this[key]);
+      const valueAsNumber = parseInt(this[key], 10);
       newValue = valueAsNumber === 0 ? 59 : valueAsNumber - 1;
     } else {
       newValue = 59;
@@ -682,7 +683,7 @@ class TimeController extends GenericController {
     this.setValuePart(key, newValue);
   }
   incrementMinuteOrSecond(key) {
-    const newValue = isValidNumber(this[key]) ? this[key] === "59" ? 0 : parseInt(this[key]) + 1 : 0;
+    const newValue = isValidNumber(this[key]) ? this[key] === "59" ? 0 : parseInt(this[key], 10) + 1 : 0;
     this.setValuePart(key, newValue);
   }
   setHourFormat() {
@@ -778,7 +779,7 @@ class TimeController extends GenericController {
         value: this.meridiem
       });
       if (isValidNumber(this.hour)) {
-        const hourAsNumber = parseInt(this.hour);
+        const hourAsNumber = parseInt(this.hour, 10);
         switch (value) {
           case "AM":
             if (hourAsNumber >= 12) {