cx 25.2.0 → 25.3.1

package/src/ui/FocusManager.js

@@ -1,171 +1,171 @@
-import { isSelfOrDescendant, findFirst, findFirstChild, isFocusable, closestParent } from "../util/DOM";
-import { batchUpdates } from "./batchUpdates";
-import { SubscriberList } from "../util/SubscriberList";
-import { isTouchEvent } from "../util/isTouchEvent";
-import { getActiveElement } from "../util/getActiveElement";
-
-/*
- *  Purpose of FocusManager is to provide focusout notifications.
- *  IE and Firefox do not provide relatedTarget info in blur events which makes it impossible
- *  to determine if focus went outside or stayed inside the component.
- */
-
-let subscribers = new SubscriberList(),
-   timerInterval = 300,
-   timerId = null;
-
-let lastActiveElement = null;
-let pending = false;
-
-export class FocusManager {
-   static subscribe(callback) {
-      let unsubscribe = subscribers.subscribe(callback);
-      checkTimer();
-      return unsubscribe;
-   }
-
-   static onFocusOut(el, callback) {
-      let active = isSelfOrDescendant(el, getActiveElement());
-      return this.subscribe((focusedEl) => {
-         if (!active) active = isSelfOrDescendant(el, getActiveElement());
-         else if (!isSelfOrDescendant(el, focusedEl)) {
-            active = false;
-            callback(focusedEl);
-         }
-      });
-   }
-
-   static oneFocusOut(el, callback) {
-      this.nudge();
-      let off = this.subscribe((focusedEl) => {
-         if (!isSelfOrDescendant(el, focusedEl)) {
-            callback(focusedEl);
-            off();
-         }
-      });
-      return off;
-   }
-
-   static nudge() {
-      if (typeof document !== "undefined" && getActiveElement() !== lastActiveElement) {
-         if (!pending) {
-            pending = true;
-            setTimeout(function () {
-               pending = false;
-               if (getActiveElement() !== lastActiveElement) {
-                  lastActiveElement = getActiveElement();
-                  batchUpdates(() => {
-                     subscribers.notify(lastActiveElement);
-                  });
-                  checkTimer();
-               }
-            }, 0);
-         }
-      }
-   }
-
-   static focus(el) {
-      el.focus();
-      this.nudge();
-   }
-
-   static focusFirst(el) {
-      let focusable = findFirst(el, isFocusable);
-      if (focusable) this.focus(focusable);
-      return focusable;
-   }
-
-   static focusFirstChild(el) {
-      let focusable = findFirstChild(el, isFocusable);
-      if (focusable) this.focus(focusable);
-      return focusable;
-   }
-
-   static focusNext(el) {
-      let next = el,
-         skip = true;
-      do {
-         if (!skip) {
-            let focusable = this.focusFirst(next);
-            if (focusable) return focusable;
-         }
-
-         if (next.nextSibling) {
-            next = next.nextSibling;
-            skip = false;
-         } else {
-            next = next.parentNode;
-            skip = true;
-         }
-      } while (next);
-   }
-
-   static setInterval(interval) {
-      timerInterval = interval;
-      checkTimer();
-   }
-}
-
-export function oneFocusOut(component, el, callback) {
-   if (!component.oneFocusOut)
-      component.oneFocusOut = FocusManager.oneFocusOut(el, (focus) => {
-         delete component.oneFocusOut;
-         callback(focus);
-      });
-}
-
-export function offFocusOut(component) {
-   if (component.oneFocusOut) {
-      component.oneFocusOut();
-      delete component.oneFocusOut;
-   }
-}
-
-export function preventFocus(e) {
-   //Focus can be prevented only on mousedown event. On touchstart this will not work
-   //preventDefault cannot be used as it prevents scrolling
-   if (e.type !== "mousedown") return;
-
-   e.preventDefault();
-
-   unfocusElement(e.currentTarget, false);
-}
-
-function checkTimer() {
-   let shouldRun = !subscribers.isEmpty();
-
-   if (shouldRun && !timerId)
-      timerId = setInterval(() => {
-         FocusManager.nudge();
-      }, timerInterval);
-
-   if (!shouldRun && timerId) {
-      clearInterval(timerId);
-      timerId = null;
-   }
-}
-
-export function preventFocusOnTouch(e, force = false) {
-   if (force || isTouchEvent()) preventFocus(e);
-}
-
-export function unfocusElement(target = null, unfocusParentOverlay = true) {
-   const activeElement = getActiveElement();
-   if (!target) target = activeElement;
-
-   if (unfocusParentOverlay) {
-      let focusableOverlayContainer = closestParent(target, (el) => el.dataset?.focusableOverlayContainer);
-      if (focusableOverlayContainer) target = focusableOverlayContainer;
-   }
-
-   //find the closest focusable parent of the target element and focus it instead
-   let focusableParent = closestParent(
-      target,
-      (el) => isFocusable(el) && (!unfocusParentOverlay || el.dataset?.focusableOverlayContainer),
-   );
-
-   if (focusableParent && focusableParent !== document.body) focusableParent.focus({ preventScroll: true });
-   else activeElement.blur();
-
-   FocusManager.nudge();
-}
+import { isSelfOrDescendant, findFirst, findFirstChild, isFocusable, closestParent } from "../util/DOM";
+import { batchUpdates } from "./batchUpdates";
+import { SubscriberList } from "../util/SubscriberList";
+import { isTouchEvent } from "../util/isTouchEvent";
+import { getActiveElement } from "../util/getActiveElement";
+
+/*
+ *  Purpose of FocusManager is to provide focusout notifications.
+ *  IE and Firefox do not provide relatedTarget info in blur events which makes it impossible
+ *  to determine if focus went outside or stayed inside the component.
+ */
+
+let subscribers = new SubscriberList(),
+   timerInterval = 300,
+   timerId = null;
+
+let lastActiveElement = null;
+let pending = false;
+
+export class FocusManager {
+   static subscribe(callback) {
+      let unsubscribe = subscribers.subscribe(callback);
+      checkTimer();
+      return unsubscribe;
+   }
+
+   static onFocusOut(el, callback) {
+      let active = isSelfOrDescendant(el, getActiveElement());
+      return this.subscribe((focusedEl) => {
+         if (!active) active = isSelfOrDescendant(el, getActiveElement());
+         else if (!isSelfOrDescendant(el, focusedEl)) {
+            active = false;
+            callback(focusedEl);
+         }
+      });
+   }
+
+   static oneFocusOut(el, callback) {
+      this.nudge();
+      let off = this.subscribe((focusedEl) => {
+         if (!isSelfOrDescendant(el, focusedEl)) {
+            callback(focusedEl);
+            off();
+         }
+      });
+      return off;
+   }
+
+   static nudge() {
+      if (typeof document !== "undefined" && getActiveElement() !== lastActiveElement) {
+         if (!pending) {
+            pending = true;
+            setTimeout(function () {
+               pending = false;
+               if (getActiveElement() !== lastActiveElement) {
+                  lastActiveElement = getActiveElement();
+                  batchUpdates(() => {
+                     subscribers.notify(lastActiveElement);
+                  });
+                  checkTimer();
+               }
+            }, 0);
+         }
+      }
+   }
+
+   static focus(el) {
+      el.focus();
+      this.nudge();
+   }
+
+   static focusFirst(el) {
+      let focusable = findFirst(el, isFocusable);
+      if (focusable) this.focus(focusable);
+      return focusable;
+   }
+
+   static focusFirstChild(el) {
+      let focusable = findFirstChild(el, isFocusable);
+      if (focusable) this.focus(focusable);
+      return focusable;
+   }
+
+   static focusNext(el) {
+      let next = el,
+         skip = true;
+      do {
+         if (!skip) {
+            let focusable = this.focusFirst(next);
+            if (focusable) return focusable;
+         }
+
+         if (next.nextSibling) {
+            next = next.nextSibling;
+            skip = false;
+         } else {
+            next = next.parentNode;
+            skip = true;
+         }
+      } while (next);
+   }
+
+   static setInterval(interval) {
+      timerInterval = interval;
+      checkTimer();
+   }
+}
+
+export function oneFocusOut(component, el, callback) {
+   if (!component.oneFocusOut)
+      component.oneFocusOut = FocusManager.oneFocusOut(el, (focus) => {
+         delete component.oneFocusOut;
+         callback(focus);
+      });
+}
+
+export function offFocusOut(component) {
+   if (component.oneFocusOut) {
+      component.oneFocusOut();
+      delete component.oneFocusOut;
+   }
+}
+
+export function preventFocus(e) {
+   //Focus can be prevented only on mousedown event. On touchstart this will not work
+   //preventDefault cannot be used as it prevents scrolling
+   if (e.type !== "mousedown") return;
+
+   e.preventDefault();
+
+   unfocusElement(e.currentTarget, false);
+}
+
+function checkTimer() {
+   let shouldRun = !subscribers.isEmpty();
+
+   if (shouldRun && !timerId)
+      timerId = setInterval(() => {
+         FocusManager.nudge();
+      }, timerInterval);
+
+   if (!shouldRun && timerId) {
+      clearInterval(timerId);
+      timerId = null;
+   }
+}
+
+export function preventFocusOnTouch(e, force = false) {
+   if (force || isTouchEvent()) preventFocus(e);
+}
+
+export function unfocusElement(target = null, unfocusParentOverlay = true) {
+   const activeElement = getActiveElement();
+   if (!target) target = activeElement;
+
+   if (unfocusParentOverlay) {
+      let focusableOverlayContainer = closestParent(target, (el) => el.dataset?.focusableOverlayContainer);
+      if (focusableOverlayContainer) target = focusableOverlayContainer;
+   }
+
+   //find the closest focusable parent of the target element and focus it instead
+   let focusableParent = closestParent(
+      target,
+      (el) => isFocusable(el) && (!unfocusParentOverlay || el.dataset?.focusableOverlayContainer),
+   );
+
+   if (focusableParent && focusableParent !== document.body) focusableParent.focus({ preventScroll: true });
+   else activeElement.blur();
+
+   FocusManager.nudge();
+}

package/src/ui/Format.js

@@ -1,108 +1,108 @@
-import { Culture, getCurrentCultureCache } from "./Culture";
-import { Format as Fmt, resolveMinMaxFractionDigits, setGetFormatCacheCallback } from "../util/Format";
-import { setGetExpressionCacheCallback } from "../data/Expression";
-import { setGetStringTemplateCacheCallback } from "../data/StringTemplate";
-import { parseDateInvariant } from "../util";
-import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
-
-export const Format = Fmt;
-
-let cultureSensitiveFormatsRegistered = false;
-
-export function resolveNumberFormattingFlags(flags) {
-   if (!flags) return null;
-   let result = {};
-   if (flags.indexOf("+") >= 0) result.signDisplay = "exceptZero";
-   if (flags.indexOf("c") >= 0) result.notation = "compact";
-   if (flags.indexOf("a") >= 0) result.currencySign = "accounting";
-   return result;
-}
-
-export function enableCultureSensitiveFormatting() {
-   if (cultureSensitiveFormatsRegistered) return;
-
-   cultureSensitiveFormatsRegistered = true;
-
-   Fmt.registerFactory(["number", "n"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-
-      let formatter = culture.getFormatter({
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-
-      return (value) => formatter.format(value);
-   });
-
-   Fmt.registerFactory("currency", (format, currency, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-      currency = currency || Culture.defaultCurrency;
-
-      let formatter = culture.getFormatter({
-         style: "currency",
-         currency: currency,
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-
-      return (value) => formatter.format(value);
-   });
-
-   Fmt.registerFactory(["percentage", "p", "%"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-      let formatter = culture.getFormatter({
-         style: "percent",
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-      return (value) => formatter.format(value);
-   });
-
-   Fmt.registerFactory(["percentSign", "ps"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
-      let culture = Culture.getNumberCulture();
-      let formatter = culture.getFormatter({
-         style: "percent",
-         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
-         ...resolveNumberFormattingFlags(flags),
-      });
-      return (value) => formatter.format(value / 100);
-   });
-
-   Fmt.registerFactory(["date", "d"], (fmt, format = "yyyyMMdd") => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return (value) => formatter.format(parseDateInvariant(value));
-   });
-
-   Fmt.registerFactory(["time", "t"], (fmt, format = "hhmmss") => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return (value) => formatter.format(parseDateInvariant(value));
-   });
-
-   Fmt.registerFactory(["datetime", "dt"], (fmt, format = "yyyyMd hhmm") => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return (value) => formatter.format(parseDateInvariant(value));
-   });
-
-   setGetFormatCacheCallback(() => {
-      let cache = getCurrentCultureCache();
-      if (!cache.formatCache) cache.formatCache = {};
-      return cache.formatCache;
-   });
-
-   setGetExpressionCacheCallback(() => {
-      let cache = getCurrentCultureCache();
-      if (!cache.exprCache) cache.exprCache = {};
-      return cache.exprCache;
-   });
-
-   setGetStringTemplateCacheCallback(() => {
-      let cache = getCurrentCultureCache();
-      if (!cache.strTplCache) cache.strTplCache = {};
-      return cache.strTplCache;
-   });
-
-   GlobalCacheIdentifier.change();
-}
+import { Culture, getCurrentCultureCache } from "./Culture";
+import { Format as Fmt, resolveMinMaxFractionDigits, setGetFormatCacheCallback } from "../util/Format";
+import { setGetExpressionCacheCallback } from "../data/Expression";
+import { setGetStringTemplateCacheCallback } from "../data/StringTemplate";
+import { parseDateInvariant } from "../util";
+import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
+
+export const Format = Fmt;
+
+let cultureSensitiveFormatsRegistered = false;
+
+export function resolveNumberFormattingFlags(flags) {
+   if (!flags) return null;
+   let result = {};
+   if (flags.indexOf("+") >= 0) result.signDisplay = "exceptZero";
+   if (flags.indexOf("c") >= 0) result.notation = "compact";
+   if (flags.indexOf("a") >= 0) result.currencySign = "accounting";
+   return result;
+}
+
+export function enableCultureSensitiveFormatting() {
+   if (cultureSensitiveFormatsRegistered) return;
+
+   cultureSensitiveFormatsRegistered = true;
+
+   Fmt.registerFactory(["number", "n"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+
+      let formatter = culture.getFormatter({
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory("currency", (format, currency, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      currency = currency || Culture.defaultCurrency;
+
+      let formatter = culture.getFormatter({
+         style: "currency",
+         currency: currency,
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory(["percentage", "p", "%"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      let formatter = culture.getFormatter({
+         style: "percent",
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory(["percentSign", "ps"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      let formatter = culture.getFormatter({
+         style: "percent",
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+      return (value) => formatter.format(value / 100);
+   });
+
+   Fmt.registerFactory(["date", "d"], (fmt, format = "yyyyMMdd") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(parseDateInvariant(value));
+   });
+
+   Fmt.registerFactory(["time", "t"], (fmt, format = "hhmmss") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(parseDateInvariant(value));
+   });
+
+   Fmt.registerFactory(["datetime", "dt"], (fmt, format = "yyyyMd hhmm") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(parseDateInvariant(value));
+   });
+
+   setGetFormatCacheCallback(() => {
+      let cache = getCurrentCultureCache();
+      if (!cache.formatCache) cache.formatCache = {};
+      return cache.formatCache;
+   });
+
+   setGetExpressionCacheCallback(() => {
+      let cache = getCurrentCultureCache();
+      if (!cache.exprCache) cache.exprCache = {};
+      return cache.exprCache;
+   });
+
+   setGetStringTemplateCacheCallback(() => {
+      let cache = getCurrentCultureCache();
+      if (!cache.strTplCache) cache.strTplCache = {};
+      return cache.strTplCache;
+   });
+
+   GlobalCacheIdentifier.change();
+}