cx 25.11.1 → 26.0.1

package/src/util/TraversalStack.spec.ts

@@ -0,0 +1,54 @@
+import { TraversalStack } from './TraversalStack';
+
+import assert from 'assert';
+
+interface TreeNode {
+   id: number;
+   children?: TreeNode[];
+}
+
+describe('TraversalStack', function () {
+
+   it('push', function () {
+      let stack = new TraversalStack<number>();
+      stack.push(1);
+      assert.equal(stack.pop(), 1);
+   });
+
+   it('traverses the tree in the right order', function () {
+      let stack = new TraversalStack<TreeNode>();
+
+      let tree: TreeNode = {
+         id: 1,
+         children: [{
+            id: 2,
+            children: [{
+               id: 3
+            }, {
+               id: 4
+            }]
+         }, {
+            id: 5,
+            children: [{
+               id: 6
+            }]
+         }]
+      };
+
+      let list: number[] = [];
+      stack.push(tree);
+      while (!stack.empty()) {
+         let node = stack.pop();
+         if (node) {
+            list.push(node.id);
+            if (node.children) {
+               stack.hop();
+               node.children.forEach((child) => {
+                  stack.push(child);
+               })
+            }
+         }
+      }
+      assert.deepEqual(list, [1, 2, 3, 4, 5, 6]);
+   });
+});

package/src/util/TraversalStack.ts

@@ -0,0 +1,48 @@
+interface StackLine<T> {
+   elements: T[];
+   index: number;
+}
+
+export class TraversalStack<T> {
+   private data: StackLine<T>[];
+
+   constructor() {
+      this.data = [];
+   }
+
+   push(node: T): void {
+      if (this.data.length == 0)
+         this.hop();
+
+      this.data[this.data.length - 1].elements.push(node);
+   }
+
+   hop(): void {
+      this.data.push({
+         elements: [],
+         index: 0
+      });
+   }
+
+   pop(): T | null {
+      while (this.data.length > 0) {
+         let line = this.data[this.data.length - 1];
+         if (line.index < line.elements.length) {
+            line.index++;
+            return line.elements[line.index - 1];
+         }
+         this.data.pop();
+      }
+      return null;
+   }
+
+   empty(): boolean {
+      while (this.data.length > 0) {
+         let line = this.data[this.data.length - 1];
+         if (line.index < line.elements.length)
+            return false;
+         this.data.pop();
+      }
+      return true;
+   }
+}

package/src/util/addEventListenerWithOptions.ts

@@ -0,0 +1,41 @@
+import { browserSupportsPassiveEventHandlers } from "./browserSupportsPassiveEventHandlers";
+
+interface EventMap {
+   wheel: WheelEvent;
+   scroll: Event;
+   click: MouseEvent;
+   mousedown: MouseEvent;
+   mouseup: MouseEvent;
+   mousemove: MouseEvent;
+   touchstart: TouchEvent;
+   touchmove: TouchEvent;
+   touchend: TouchEvent;
+   keydown: KeyboardEvent;
+   keyup: KeyboardEvent;
+   keypress: KeyboardEvent;
+}
+
+export function addEventListenerWithOptions<K extends keyof EventMap>(
+   element: Element,
+   event: K,
+   callback: (event: EventMap[K]) => void,
+   options: AddEventListenerOptions
+): () => void;
+export function addEventListenerWithOptions(
+   element: Element,
+   event: string,
+   callback: (event: Event) => void,
+   options: AddEventListenerOptions
+): () => void;
+export function addEventListenerWithOptions(
+   element: Element,
+   event: string,
+   callback: (event: Event) => void,
+   options: AddEventListenerOptions
+): () => void {
+   let thirdParam = browserSupportsPassiveEventHandlers() ? options : options.capture === true;
+   element.addEventListener(event, callback as any, thirdParam);
+   return () => {
+      element.removeEventListener(event, callback as any, thirdParam);
+   };
+}

package/src/util/browserSupportsPassiveEventHandlers.ts

@@ -0,0 +1,20 @@
+let passiveEventsSupported: boolean | null = null;
+
+/**
+ * Checks if the browser supports passive event handlers.
+ * @returns {boolean}
+ */
+export function browserSupportsPassiveEventHandlers(): boolean {
+   if (passiveEventsSupported == null) {
+      try {
+         passiveEventsSupported = false;
+         const options = Object.defineProperty({}, "passive", {
+            get() {
+               passiveEventsSupported = true;
+            },
+         });
+         window.addEventListener("test" as any, null as any, options);
+      } catch (e) {}
+   }
+   return passiveEventsSupported!;
+}

package/src/util/calculateNaturalElementHeight.ts

@@ -0,0 +1,22 @@
+export function calculateNaturalElementHeight(el: HTMLElement): number {
+   if (el.scrollHeight > el.clientHeight) return naturalElementHeight(el);
+   let h = el.offsetHeight;
+   for (let i = 0; i < el.children.length; i++) {
+      let child = el.children[i];
+      if (child instanceof HTMLElement && child.scrollHeight > child.clientHeight) {
+         h -= child.offsetHeight;
+         h += naturalElementHeight(child);
+      }
+   }
+   return h;
+}
+
+function naturalElementHeight(el: HTMLElement): number {
+   let h = el.offsetHeight;
+   let overflow = el.scrollHeight - el.clientHeight;
+   if (overflow <= 0) return h;
+   let computedStyle = getComputedStyle(el);
+   let maxH = parseFloat(computedStyle.getPropertyValue("max-height"));
+   if (!isNaN(maxH)) return Math.min(maxH, h + overflow);
+   return h + overflow;
+}

package/src/util/capitalize.ts

@@ -0,0 +1,4 @@
+export function capitalize(str: string): string {
+   if (typeof str != "string") return str;
+   return str.charAt(0).toUpperCase() + str.substring(1);
+}

package/src/util/coalesce.ts

@@ -0,0 +1,6 @@
+export function coalesce(...args: any[]): any {
+   for (let i = 0; i < args.length; i++) {
+      if (args[i] != null) return args[i];
+   }
+   return null;
+}

package/src/util/color/hslToRgb.ts

@@ -0,0 +1,34 @@
+function hue2rgb(p: number, q: number, t: number): number {
+   if (t < 0) t += 1;
+   if (t > 1) t -= 1;
+   if (t < 1 / 6) return p + (q - p) * 6 * t;
+   if (t < 1 / 2) return q;
+   if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+   return p;
+};
+
+/**
+ *
+ * @param h
+ * @param s
+ * @param l
+ * @returns {array}
+ */
+export function hslToRgb(h: number, s: number, l: number): [number, number, number] {
+   h/=360;
+   s/=100;
+   l/=100;
+   var r, g, b;
+
+   if (s == 0) {
+      r = g = b = l; // achromatic
+   } else {
+      var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+      var p = 2 * l - q;
+      r = hue2rgb(p, q, h + 1 / 3);
+      g = hue2rgb(p, q, h);
+      b = hue2rgb(p, q, h - 1 / 3);
+   }
+
+   return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}

package/src/util/color/parseColor.ts

@@ -0,0 +1,173 @@
+/**
+ * An object representing `rgba` color.
+ * @typedef RGBColor
+ * @property type
+ * @property  r
+ * @property  g
+ * @property  b
+ * @property  a
+ */
+type RGBColor = {
+   type: 'rgba',
+   r: number,
+   g: number,
+   b: number,
+   a: number
+}
+
+/**
+ * An object representing `hsla` color.
+ * @typedef HSLColor
+ * @property type
+ * @property h
+ * @property s
+ * @property l
+ * @property a
+ */
+type HSLColor = {
+   type: 'hsla',
+   h: number,
+   s: number,
+   l: number,
+   a: number
+}
+
+/**
+ *
+ * @param  color
+ * @returns {RGBColor|HSLColor}
+ */
+export function parseColor(color: string | null): RGBColor | HSLColor | null {
+
+   if (!color)
+      return null;
+
+   if (color[0] == '#')
+      return parseHexColor(color);
+
+   if (color.indexOf('rgb') == 0)
+      return parseRgbColor(color);
+
+   if (color.indexOf('hsl') == 0)
+      return parseHslColor(color);
+
+   throw new Error(`Unknown color format: ${color}.`);
+}
+
+/**
+ *
+ * @param color
+ * @returns {RGBColor}
+ */
+export function parseHexColor(color: string | null): RGBColor | null {
+
+   if (!color)
+      return null;
+
+   if (color[0] != '#')
+      throw new Error(`Invalid color ${color}.`);
+
+   if (color.length == 4)
+      return {
+         type: 'rgba',
+         r: parseInt(color.charAt(1), 16) * 0x11,
+         g: parseInt(color.charAt(2), 16) * 0x11,
+         b: parseInt(color.charAt(3), 16) * 0x11,
+         a: 1
+      };
+
+   if (color.length != 7)
+      throw new Error(`Invalid color ${color}.`);
+
+   return {
+      type: 'rgba',
+      r: parseInt(color.substr(1, 2), 16),
+      g: parseInt(color.substr(3, 2), 16),
+      b: parseInt(color.substr(5, 2), 16),
+      a: 1
+   }
+}
+
+/**
+ *
+ * @param color
+ * @returns {RGBColor}
+ */
+export function parseRgbColor(color: string | null): RGBColor | null {
+   if (!color)
+      return null;
+
+   color = color.trim();
+   var values;
+
+   if (color.indexOf('rgba(') == 0) {
+      values = color.substring(5, color.length - 1).split(',').map(x=>parseFloat(x.trim()));
+      if (values.length != 4)
+         throw new Error(`Invalid color ${color}.`);
+
+      return {
+         type: 'rgba',
+         r: values[0],
+         g: values[1],
+         b: values[2],
+         a: values[3]
+      }
+   }
+
+   if (color.indexOf('rgb(') != 0)
+      throw new Error(`Invalid color ${color}.`);
+
+   values = color.substring(5, color.length - 1).split(',').map(x=>parseFloat(x.trim()));
+   if (values.length != 3)
+      throw new Error(`Invalid color ${color}.`);
+
+   return {
+      type: 'rgba',
+      r: values[0],
+      g: values[1],
+      b: values[2],
+      a: 1
+   }
+}
+
+/**
+ *
+ * @param color
+ * @returns {HSLColor}
+ */
+export function parseHslColor(color: string | null): HSLColor | null {
+   if (!color)
+      return null;
+
+   color = color.trim();
+   var values;
+
+   if (color.indexOf('hsla(') == 0) {
+      values = color.substring(5, color.length - 1).split(',').map(x=>parseFloat(x.trim()));
+      if (values.length != 4)
+         throw new Error(`Invalid color ${color}.`);
+
+      return {
+         type: 'hsla',
+         h: values[0],
+         s: values[1],
+         l: values[2],
+         a: values[3]
+      }
+   }
+
+   if (color.indexOf('hsl(') != 0)
+      throw new Error(`Invalid color ${color}.`);
+
+   values = color.substring(5, color.length - 1).split(',').map(x=>parseFloat(x.trim()));
+   if (values.length != 3)
+      throw new Error(`Invalid color ${color}.`);
+
+   return {
+      type: 'hsla',
+      h: values[0],
+      s: values[1],
+      l: values[2],
+      a: 1
+   }
+}

package/src/util/color/rgbToHex.ts

@@ -0,0 +1,15 @@
+function componentToHex(c: number): string {
+   var hex = c.toString(16);
+   return hex.length == 1 ? "0" + hex : hex;
+}
+
+/**
+ *
+ * @param r
+ * @param g
+ * @param b
+ * @returns {string}
+ */
+export function rgbToHex(r: number, g: number, b: number): string {
+   return "#" + componentToHex(r) + componentToHex(g) + componentToHex(b);
+}

package/src/util/color/rgbToHsl.ts

@@ -0,0 +1,36 @@
+/**
+ *
+ * @param r
+ * @param g
+ * @param b
+ * @returns {array}
+ */
+export function rgbToHsl(r: number, g: number, b: number): [number, number, number] {
+   r /= 255;
+   g /= 255;
+   b /= 255;
+   let max = Math.max(r, g, b), min = Math.min(r, g, b);
+   let h: number, s: number, l = (max + min) / 2;
+
+   if (max == min) {
+      h = s = 0; // achromatic
+   } else {
+      let d = max - min;
+      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+      switch (max) {
+         case r:
+            h = (g - b) / d + (g < b ? 6 : 0);
+            break;
+         case g:
+            h = (b - r) / d + 2;
+            break;
+         case b:
+         default:
+            h = (r - g) / d + 4;
+            break;
+      }
+      h /= 6;
+   }
+
+   return [h * 360, s * 100, l * 100]
+}

package/src/util/date/dateDiff.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns the difference between two dates in miliseconds.
+ * @param d1
+ * @param d2
+ * @returns {number}
+ */
+export function dateDiff(d1: Date, d2: Date): number {
+   return d1.getTime() - d2.getTime();
+};

package/src/util/date/diff.ts

@@ -0,0 +1,13 @@
+import {debug, deprecatedFlag} from '../../util/Debug';
+
+debug(deprecatedFlag, 'date/diff function is deprecated since v16.8. It will be removed in future versions. Use dateDiff instead.');
+
+/**
+ * @deprecated
+ * date/diff function is deprecated since v16.8. It will be removed in future versions. Use dateDiff instead.
+ * @param d1
+ * @param d2
+ */
+export function diff(d1: Date, d2: Date): number {
+   return d1.getTime() - d2.getTime();
+}

package/src/util/date/encodeDate.ts

@@ -0,0 +1,8 @@
+function pad(num: number): string {
+   const norm = Math.floor(Math.abs(num));
+   return (norm < 10 ? "0" : "") + norm;
+}
+
+export function encodeDate(date: Date): string {
+   return date.getFullYear() + "-" + pad(date.getMonth() + 1) + "-" + pad(date.getDate());
+}

package/src/util/date/encodeDateWithTimezoneOffset.ts

@@ -0,0 +1,19 @@
+//https://stackoverflow.com/questions/17415579/how-to-iso-8601-format-a-date-with-timezone-offset-in-javascript
+
+function pad(num: number): string {
+   const norm = Math.floor(Math.abs(num));
+   return (norm < 10 ? '0' : '') + norm;
+}
+
+export function encodeDateWithTimezoneOffset(date: Date): string {
+   const tzo = -date.getTimezoneOffset(),
+      dif = tzo >= 0 ? '+' : '-';
+   return date.getFullYear() +
+      '-' + pad(date.getMonth() + 1) +
+      '-' + pad(date.getDate()) +
+      'T' + pad(date.getHours()) +
+      ':' + pad(date.getMinutes()) +
+      ':' + pad(date.getSeconds()) +
+      dif + pad(tzo / 60) +
+      ':' + pad(tzo % 60);
+}

package/src/util/date/lowerBoundCheck.ts

@@ -0,0 +1,13 @@
+import {dateDiff} from './dateDiff';
+
+/**
+ * Checks `date` against the lower bound `minDate`. Set `exclusive` to true to disallow the border value.
+ * @param date
+ * @param minDate
+ * @param [exclusive=false]
+ * @returns {boolean}
+ */
+export function lowerBoundCheck(date: Date, minDate: Date, exclusive: boolean = false): boolean {
+   var d = dateDiff(date, minDate);
+   return d > 0 || (d == 0 && !exclusive);
+}

package/src/util/date/maxDate.ts

@@ -0,0 +1,14 @@
+import {dateDiff} from './dateDiff';
+
+/**
+ * Returns the maximum Date value from the provided values.
+ * @param args
+ * @returns {Date}
+ */
+export function maxDate(...args: Date[]): Date {
+   var max = args[0];
+   for (var i = 1; i < args.length; i++)
+      if (dateDiff(max, args[i]) < 0)
+         max = args[i];
+   return max;
+}

package/src/util/date/minDate.ts

@@ -0,0 +1,14 @@
+import {dateDiff} from './dateDiff';
+
+/**
+ * Returns the minimum Date value from the provided values.
+ * @param args
+ * @returns {Date}
+ */
+export function minDate(...args: Date[]): Date {
+   var min = args[0];
+   for (var i = 1; i<args.length; i++)
+      if (dateDiff(min, args[i]) > 0)
+         min = args[i];
+   return min;
+}

package/src/util/date/monthStart.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the date representing the beginning of the month in respect to the date provided.
+ * @param d
+ * @returns {Date}
+ */
+export function monthStart(d: Date): Date {
+   return new Date(d.getFullYear(), d.getMonth(), 1);
+}

package/src/util/date/parseDateInvariant.ts

@@ -0,0 +1,20 @@
+// This module addresses a common issue when handling date strings in the format "yyyy-MM-dd" usually returned by backends.
+// In time zones earlier than UTC, creating a Date object from such a string can result in the date being shifted one day earlier.
+// This happens because "yyyy-MM-dd" is interpreted as a UTC date at 00:00, and when the browser displays it in local time, it adjusts backward.
+// To resolve this, the default implementation (`defaultInvariantParseDate`) appends " 00:00" to the date string,
+// explicitly indicating local time. Custom parsing logic can also be registered dynamically using `registerInvariantParseDateImpl`
+// to accommodate other formats or requirements.
+function defaultParseDateInvariant(input: string | number | Date): Date {
+   if (typeof input == "string" && input.length == 10 && input[4] == "-" && input[7] == "-")
+      return new Date(`${input} 00:00`);
+   return new Date(input);
+}
+let impl: (input: string | number | Date) => Date = defaultParseDateInvariant;
+
+export function parseDateInvariant(input: string | number | Date): Date {
+   return impl(input);
+}
+
+export function overrideParseDateInvariant(newImpl: (input: string | number | Date) => Date): void {
+   impl = newImpl;
+}

package/src/util/date/sameDate.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns `true` if the dates provided represent the same day.
+ * @param d1
+ * @param d2
+ * @returns {boolean}
+ */
+export function sameDate(d1: Date, d2: Date): boolean {
+   return d1.getDate() == d2.getDate()
+      && d1.getMonth() == d2.getMonth()
+      && d1.getFullYear() == d2.getFullYear();
+}

package/src/util/date/upperBoundCheck.ts

@@ -0,0 +1,13 @@
+import {dateDiff} from './dateDiff';
+
+/**
+ * Checks `date` against the upper bound `maxDate`. Set `exclusive` to true to disallow the border value.
+ * @param date
+ * @param maxDate
+ * @param exclusive
+ * @returns {boolean}
+ */
+export function upperBoundCheck(date: Date, maxDate: Date, exclusive: boolean = false): boolean {
+   var d = dateDiff(date, maxDate);
+   return d < 0 || (d == 0 && !exclusive);
+}

package/src/util/date/zeroTime.ts

@@ -0,0 +1,9 @@
+/**
+ * Zeros out time for the given Date object. E.g. for date object representing Wed Apr 19 2017 14:31:51 GMT+0200
+ * returns Wed Apr 19 2017 00:00:00 GMT+0200.
+ * @param d
+ * @returns {Date}
+ */
+export function zeroTime(d: Date): Date {
+   return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+}

package/src/util/debounce.ts

@@ -0,0 +1,26 @@
+export interface DebouncedFunction<T extends (...args: any[]) => any> {
+   (...args: Parameters<T>): void;
+   reset(...args: Parameters<T>): void;
+}
+
+export function debounce<T extends (...args: any[]) => any>(
+   callback: T,
+   delay: number
+): DebouncedFunction<T> {
+   let timer: ReturnType<typeof setTimeout> | undefined;
+
+   const result = function (this: any, ...args: Parameters<T>): void {
+      const context = this;
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+         callback.apply(context, args);
+      }, delay);
+   } as DebouncedFunction<T>;
+
+   result.reset = function (this: any, ...args: Parameters<T>): void {
+      clearTimeout(timer);
+      callback.apply(this, args);
+   };
+
+   return result;
+}

package/src/util/dummyCallback.ts

@@ -0,0 +1 @@
+export function dummyCallback(): void {}

package/src/util/escapeSpecialRegexCharacters.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param s
+ * @return {string}
+ */
+export function escapeSpecialRegexCharacters(s: string): string {
+   return s.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+}

package/src/util/eventCallbacks.ts

@@ -0,0 +1,12 @@
+interface SyntheticEvent<T> {
+   stopPropagation(): void;
+   preventDefault(): void;
+}
+
+export function stopPropagation(e: SyntheticEvent<any>): void {
+   e.stopPropagation();
+}
+
+export function preventDefault(e: SyntheticEvent<any>): void {
+   e.preventDefault();
+}