cx 24.9.3 → 24.9.4

package/src/util/Component.js

@@ -1,108 +1,108 @@
-import {isString} from './isString';
-import {isFunction} from './isFunction';
-import {isArray} from './isArray';
-
-const componentAlias = {};
-
-export class Component {
-   constructor(config) {
-      if (config && config.$props) {
-         Object.assign(config, config.$props);
-         delete config.$props;
-      }
-      Object.assign(this, config);
-   }
-
-   static alias(alias, type) {
-      if (type) {
-         type.prototype.componentAlias = alias;
-         componentAlias[this.namespace + alias] = type;
-      }
-      else //decorator usage
-         return t => {
-            this.alias(alias, t);
-            return t;
-         }
-   }
-
-   static create(typeAlias, config, more) {
-      if (!typeAlias)
-         return this.factory(typeAlias, config, more);
-
-      if (typeAlias.isComponent)
-         return typeAlias;
-
-      if (isComponentFactory(typeAlias))
-         return this.create(typeAlias.create(config));
-
-      if (isArray(typeAlias))
-         return typeAlias.map(c => this.create(c, config, more));
-
-      if (typeAlias.$type)
-         return this.create(typeAlias.$type, typeAlias, config);
-
-      if (typeAlias.type)
-         return this.create(typeAlias.type, typeAlias, config);
-
-      let cmpType, alias;
-
-      if (typeAlias.isComponentType)
-         cmpType = typeAlias;
-      else if (isFunction(typeAlias)) {
-         if (this.factory)
-            return this.factory(typeAlias, config, more)
-         throw new Error(`Unsupported component type ${typeAlias}.`);
-      }
-      else if (isString(typeAlias)) {
-         alias = this.namespace + typeAlias;
-         cmpType = componentAlias[alias];
-         if (!cmpType) {
-            if (typeAlias && this.factory)
-               return this.factory(typeAlias, config, more);
-            throw new Error(`Unknown component alias ${alias}.`);
-         }
-      }
-      else if (typeof typeAlias == 'object') {
-         cmpType = typeAlias.type || typeAlias.$type;
-         if (!cmpType) {
-            cmpType = this;
-            more = more ? Object.assign({}, config, more) : config;
-            config = typeAlias;
-         }
-      }
-
-      if (isArray(config))
-         return config.map(cfg => this.create(cmpType, cfg, more));
-
-      let cfg = config;
-
-      if (more)
-         cfg = Object.assign({}, config, more);
-
-      let cmp = new cmpType(cfg);
-      if (cmpType.autoInit && cmp.init)
-         cmp.init();
-      return cmp;
-   }
-}
-
-Component.prototype.isComponent = true;
-
-Component.isComponentType = true;
-Component.namespace = '';
-Component.autoInit = false;
-
-Component.factory = (alias, config, more) => {
-   throw new Error(`Unknown component alias ${alias}.`);
-};
-
-export function createComponentFactory(factory, jsxDriver, meta) {
-   factory.$isComponentFactory = true;
-   factory.$meta = meta;
-   factory.create = jsxDriver;
-   return factory;
-}
-
-export function isComponentFactory(factory) {
-   return factory && factory.$isComponentFactory;
+import {isString} from './isString';
+import {isFunction} from './isFunction';
+import {isArray} from './isArray';
+
+const componentAlias = {};
+
+export class Component {
+   constructor(config) {
+      if (config && config.$props) {
+         Object.assign(config, config.$props);
+         delete config.$props;
+      }
+      Object.assign(this, config);
+   }
+
+   static alias(alias, type) {
+      if (type) {
+         type.prototype.componentAlias = alias;
+         componentAlias[this.namespace + alias] = type;
+      }
+      else //decorator usage
+         return t => {
+            this.alias(alias, t);
+            return t;
+         }
+   }
+
+   static create(typeAlias, config, more) {
+      if (!typeAlias)
+         return this.factory(typeAlias, config, more);
+
+      if (typeAlias.isComponent)
+         return typeAlias;
+
+      if (isComponentFactory(typeAlias))
+         return this.create(typeAlias.create(config));
+
+      if (isArray(typeAlias))
+         return typeAlias.map(c => this.create(c, config, more));
+
+      if (typeAlias.$type)
+         return this.create(typeAlias.$type, typeAlias, config);
+
+      if (typeAlias.type)
+         return this.create(typeAlias.type, typeAlias, config);
+
+      let cmpType, alias;
+
+      if (typeAlias.isComponentType)
+         cmpType = typeAlias;
+      else if (isFunction(typeAlias)) {
+         if (this.factory)
+            return this.factory(typeAlias, config, more)
+         throw new Error(`Unsupported component type ${typeAlias}.`);
+      }
+      else if (isString(typeAlias)) {
+         alias = this.namespace + typeAlias;
+         cmpType = componentAlias[alias];
+         if (!cmpType) {
+            if (typeAlias && this.factory)
+               return this.factory(typeAlias, config, more);
+            throw new Error(`Unknown component alias ${alias}.`);
+         }
+      }
+      else if (typeof typeAlias == 'object') {
+         cmpType = typeAlias.type || typeAlias.$type;
+         if (!cmpType) {
+            cmpType = this;
+            more = more ? Object.assign({}, config, more) : config;
+            config = typeAlias;
+         }
+      }
+
+      if (isArray(config))
+         return config.map(cfg => this.create(cmpType, cfg, more));
+
+      let cfg = config;
+
+      if (more)
+         cfg = Object.assign({}, config, more);
+
+      let cmp = new cmpType(cfg);
+      if (cmpType.autoInit && cmp.init)
+         cmp.init();
+      return cmp;
+   }
+}
+
+Component.prototype.isComponent = true;
+
+Component.isComponentType = true;
+Component.namespace = '';
+Component.autoInit = false;
+
+Component.factory = (alias, config, more) => {
+   throw new Error(`Unknown component alias ${alias}.`);
+};
+
+export function createComponentFactory(factory, jsxDriver, meta) {
+   factory.$isComponentFactory = true;
+   factory.$meta = meta;
+   factory.create = jsxDriver;
+   return factory;
+}
+
+export function isComponentFactory(factory) {
+   return factory && factory.$isComponentFactory;
 }

package/src/util/Console.d.ts

@@ -1,4 +1,4 @@
-export class Console {
-   static log(...args: unknown[]): void;
-   static warn(...args: unknown[]): void;
-}
+export class Console {
+   static log(...args: unknown[]): void;
+   static warn(...args: unknown[]): void;
+}

package/src/util/Console.js

@@ -1,11 +1,11 @@
-export const Console = {
-   log: function () {
-      if (typeof window != 'undefined' && window.console)
-         console.log(...arguments);
-   },
-
-   warn: function () {
-      if (typeof window != 'undefined' && window.console)
-         console.warn(...arguments);
-   }
-};
+export const Console = {
+   log: function () {
+      if (typeof window != 'undefined' && window.console)
+         console.log(...arguments);
+   },
+
+   warn: function () {
+      if (typeof window != 'undefined' && window.console)
+         console.warn(...arguments);
+   }
+};

package/src/util/DOM.d.ts

@@ -1,33 +1,33 @@
-type ElementFilter = (el: Element, condition: (el: Element) => boolean) => Element | null;
-
-/** 
- * Returns first child element, or the parent element itself, that satisfies the `condition` function.
- * @param el
- * @param condition
- * @returns {Element}
- */
-export const findFirst: ElementFilter;
-
-export const findFirstChild : ElementFilter;
-
-export const closest: ElementFilter;
-
-export const closestParent: ElementFilter;
-
-export function isFocused(el: Element) : boolean;
-
-export function isFocusedDeep(el: Element) : boolean;
-
-export function isFocusable(el: Element) : boolean;
-
-/** 
- * Returns focused element.
- * @returns {Element}
- */
-export function getFocusedElement() : Element;
-
-
-export function isDescendant(el: Element, descEl: Element) : boolean;
-
-export function isSelfOrDescendant(el: Element, descEl: Element) : boolean;
-
+type ElementFilter = (el: Element, condition: (el: Element) => boolean) => Element | null;
+
+/** 
+ * Returns first child element, or the parent element itself, that satisfies the `condition` function.
+ * @param el
+ * @param condition
+ * @returns {Element}
+ */
+export const findFirst: ElementFilter;
+
+export const findFirstChild : ElementFilter;
+
+export const closest: ElementFilter;
+
+export const closestParent: ElementFilter;
+
+export function isFocused(el: Element) : boolean;
+
+export function isFocusedDeep(el: Element) : boolean;
+
+export function isFocusable(el: Element) : boolean;
+
+/** 
+ * Returns focused element.
+ * @returns {Element}
+ */
+export function getFocusedElement() : Element;
+
+
+export function isDescendant(el: Element, descEl: Element) : boolean;
+
+export function isSelfOrDescendant(el: Element, descEl: Element) : boolean;
+

package/src/util/DOM.js

@@ -1,72 +1,72 @@
-import {isNumber} from '../util/isNumber';
-
-export function findFirst(el, condition) {
-   if (condition(el))
-      return el;
-
-   var children = el.childNodes;
-   if (children)
-      for (var i = 0; i < children.length; i++) {
-         var child = findFirst(children[i], condition);
-         if (child)
-            return child;
-      }
-   return null;
-}
-
-export function findFirstChild(el, condition) {
-   var children = el.childNodes;
-   if (children)
-      for (var i = 0; i < children.length; i++) {
-         var child = findFirst(children[i], condition);
-         if (child)
-            return child;
-      }
-   return null;
-}
-
-export function closest(el, condition) {
-   while (el) {
-      if (condition(el))
-         return el;
-      el = el.parentNode;
-   }
-   return null;
-}
-
-export function closestParent(el, condition) {
-   return el && closest(el.parentNode, condition);
-}
-
-export function isFocused(el) {
-   return document.activeElement == el;
-}
-
-export function isFocusedDeep(el) {
-   return document.activeElement == el || (document.activeElement && el.contains(document.activeElement));
-}
-
-const focusableWithoutTabIndex = ['INPUT', 'SELECT', 'TEXTAREA', 'A', 'BUTTON'];
-
-export function isFocusable(el) {
-   var firstPass = el && isNumber(el.tabIndex) && el.tabIndex >= 0;
-   if (!firstPass)
-      return false;
-
-   if (focusableWithoutTabIndex.indexOf(el.tagName) != -1 && !el.hasAttribute('disabled'))
-      return true;
-
-   return el.hasAttribute('tabindex');
-}
-
-export function getFocusedElement() {
-   return document.activeElement;
-}
-
-export function isDescendant(el, descEl) {
-   return el.contains(descEl);
-}
-
-export function isSelfOrDescendant(el, descEl) {
-   return el == descEl || el.contains(descEl);
-}
+import {isNumber} from '../util/isNumber';
+
+export function findFirst(el, condition) {
+   if (condition(el))
+      return el;
+
+   var children = el.childNodes;
+   if (children)
+      for (var i = 0; i < children.length; i++) {
+         var child = findFirst(children[i], condition);
+         if (child)
+            return child;
+      }
+   return null;
+}
+
+export function findFirstChild(el, condition) {
+   var children = el.childNodes;
+   if (children)
+      for (var i = 0; i < children.length; i++) {
+         var child = findFirst(children[i], condition);
+         if (child)
+            return child;
+      }
+   return null;
+}
+
+export function closest(el, condition) {
+   while (el) {
+      if (condition(el))
+         return el;
+      el = el.parentNode;
+   }
+   return null;
+}
+
+export function closestParent(el, condition) {
+   return el && closest(el.parentNode, condition);
+}
+
+export function isFocused(el) {
+   return document.activeElement == el;
+}
+
+export function isFocusedDeep(el) {
+   return document.activeElement == el || (document.activeElement && el.contains(document.activeElement));
+}
+
+const focusableWithoutTabIndex = ['INPUT', 'SELECT', 'TEXTAREA', 'A', 'BUTTON'];
+
+export function isFocusable(el) {
+   var firstPass = el && isNumber(el.tabIndex) && el.tabIndex >= 0;
+   if (!firstPass)
+      return false;
+
+   if (focusableWithoutTabIndex.indexOf(el.tagName) != -1 && !el.hasAttribute('disabled'))
+      return true;
+
+   return el.hasAttribute('tabindex');
+}
+
+export function getFocusedElement() {
+   return document.activeElement;
+}
+
+export function isDescendant(el, descEl) {
+   return el.contains(descEl);
+}
+
+export function isSelfOrDescendant(el, descEl) {
+   return el == descEl || el.contains(descEl);
+}

package/src/util/Debug.d.ts

@@ -1,11 +1,11 @@
-
-export class Debug {
-
-   static enable(flag: string);
-
-   static disable(flag: string);
-
-   static log(flag): string;
-}
-
+
+export class Debug {
+
+   static enable(flag: string);
+
+   static disable(flag: string);
+
+   static log(flag): string;
+}
+
 export function debug(flag: string, ...args: any[]);

package/src/util/Debug.js

@@ -1,45 +1,45 @@
-import {Console} from './Console';
-
-let activeFlags = {
-   deprecated: true
-};
-
-export function debug(flag) {
-   if (process.env.NODE_ENV !== "production") {
-      if (!activeFlags[flag])
-         return;
-
-      Console.log(...arguments);
-   }
-}
-
-export const Debug = {
-
-   enable: function(flag) {
-      if (process.env.NODE_ENV !== "production") {
-         activeFlags[flag] = true;
-      }
-   },
-
-   disable: function(flag) {
-      if (process.env.NODE_ENV !== "production") {
-         activeFlags[flag] = false;
-      }
-   },
-
-   log: debug
-};
-
-export const renderFlag = 'render';
-export const prepareFlag = 'prepare';
-export const processDataFlag = 'process-data';
-export const cleanupFlag = 'cleanup';
-export const menuFlag = 'menu';
-export const focusFlag = 'focus';
-export const internalFlag = 'internal';
-export const shouldUpdateFlag = 'should-update';
-export const appDataFlag = 'app-data';
-export const tooltipsFlag = 'tooltips';
-export const deprecatedFlag = 'deprecated';
-export const destroyFlag = 'destroy';
-
+import {Console} from './Console';
+
+let activeFlags = {
+   deprecated: true
+};
+
+export function debug(flag) {
+   if (process.env.NODE_ENV !== "production") {
+      if (!activeFlags[flag])
+         return;
+
+      Console.log(...arguments);
+   }
+}
+
+export const Debug = {
+
+   enable: function(flag) {
+      if (process.env.NODE_ENV !== "production") {
+         activeFlags[flag] = true;
+      }
+   },
+
+   disable: function(flag) {
+      if (process.env.NODE_ENV !== "production") {
+         activeFlags[flag] = false;
+      }
+   },
+
+   log: debug
+};
+
+export const renderFlag = 'render';
+export const prepareFlag = 'prepare';
+export const processDataFlag = 'process-data';
+export const cleanupFlag = 'cleanup';
+export const menuFlag = 'menu';
+export const focusFlag = 'focus';
+export const internalFlag = 'internal';
+export const shouldUpdateFlag = 'should-update';
+export const appDataFlag = 'app-data';
+export const tooltipsFlag = 'tooltips';
+export const deprecatedFlag = 'deprecated';
+export const destroyFlag = 'destroy';
+

package/src/util/Format.d.ts

@@ -1,18 +1,18 @@
-declare type Formatter = (any) => string;
-
-export class Format {
-   static value(v: any, format: string): string;
-
-   static parse(format: string): Formatter;
-
-   static register(format: string | string[], formatter: Formatter): void;
-
-   static registerFactory(format: string | string[], factory: (...args) => Formatter): void;
-}
-
-export function resolveMinMaxFractionDigits(
-   minimumFractionDigits: number,
-   maximumFractionDigits: number,
-): { minimumFractionDigits: number; maximumFractionDigits: number };
-
-export function setGetFormatCacheCallback(callback: () => {}): void;
+declare type Formatter = (any) => string;
+
+export class Format {
+   static value(v: any, format: string): string;
+
+   static parse(format: string): Formatter;
+
+   static register(format: string | string[], formatter: Formatter): void;
+
+   static registerFactory(format: string | string[], factory: (...args) => Formatter): void;
+}
+
+export function resolveMinMaxFractionDigits(
+   minimumFractionDigits: number,
+   maximumFractionDigits: number,
+): { minimumFractionDigits: number; maximumFractionDigits: number };
+
+export function setGetFormatCacheCallback(callback: () => {}): void;