cx 22.3.2 → 22.3.3

package/src/ui/selection/Selection.js

@@ -1,97 +1,97 @@
-import {Component} from '../../util/Component';
-
-export class Selection extends Component {
-   
-   isSelected(store, record, index) {
-      return this.bind && store.get(this.bind) === record;
-   }
-
-   getIsSelectedDelegate(store) {
-      return (record, index) => this.isSelected(store, record, index);
-   }
-   
-   select(store, record, index, options) {
-      this.selectMultiple(store, [record], [index], options)
-   }
-
-   selectMultiple(store, records, indexes, options) {
-      //abstract
-   }
-
-   declareData() {
-      var declaration = {
-         $selection: { structured: true }
-      };
-
-      return Object.assign(declaration, ...arguments);
-   }
-
-   configureWidget(widget) {
-
-      if (this.record || this.index) {
-         widget.$selection = Object.assign(widget.$selection || {}, {
-            record: this.record,
-            index: this.index
-         })
-      }
-
-      return this.declareData();
-   }
-
-   selectInstance(instance, options) {
-      var {store, data} = instance;
-      if (!data.$selection)
-         throw new Error('Selection model not properly configured. Using the selectInstance method without specified record and index bindings.');
-      return this.select(store, data.$selection.record, data.$selection.index, options);
-   }
-
-   isInstanceSelected(instance) {
-      var {store, data} = instance;
-      return data.$selection && this.isSelected(store, data.$selection.record, data.$selection.index);
-   }
-}
-
-Selection.prototype.toggle = false;
-
-Selection.namespace = 'ui.selection.';
-
-class SimpleSelection extends Selection {
-
-   isSelected(store, record, index) {
-      return this.getIsSelectedDelegate(store)(record, index);
-   }
-
-   getIsSelectedDelegate(store) {
-      var selection = this.bind && store.get(this.bind);
-      return (record, index) => record === selection;
-   }
-
-   selectMultiple(store, records, index) {
-      if (this.bind)
-         store.set(this.bind, records[0]);
-   }
-}
-
-class DummySelection extends Selection {
-   isSelected(store, record, index) {
-      return false;
-   }
-
-   selectMultiple() {
-      //dummy
-   }
-
-   selectInstance() {
-      //dummy
-   }
-}
-
-DummySelection.prototype.isDummy = true;
-
-Selection.factory = (name) => {
-   if (typeof name == 'object')
-      return new SimpleSelection(name);
-
-   return new DummySelection();
-};
-
+import {Component} from '../../util/Component';
+
+export class Selection extends Component {
+   
+   isSelected(store, record, index) {
+      return this.bind && store.get(this.bind) === record;
+   }
+
+   getIsSelectedDelegate(store) {
+      return (record, index) => this.isSelected(store, record, index);
+   }
+   
+   select(store, record, index, options) {
+      this.selectMultiple(store, [record], [index], options)
+   }
+
+   selectMultiple(store, records, indexes, options) {
+      //abstract
+   }
+
+   declareData() {
+      var declaration = {
+         $selection: { structured: true }
+      };
+
+      return Object.assign(declaration, ...arguments);
+   }
+
+   configureWidget(widget) {
+
+      if (this.record || this.index) {
+         widget.$selection = Object.assign(widget.$selection || {}, {
+            record: this.record,
+            index: this.index
+         })
+      }
+
+      return this.declareData();
+   }
+
+   selectInstance(instance, options) {
+      var {store, data} = instance;
+      if (!data.$selection)
+         throw new Error('Selection model not properly configured. Using the selectInstance method without specified record and index bindings.');
+      return this.select(store, data.$selection.record, data.$selection.index, options);
+   }
+
+   isInstanceSelected(instance) {
+      var {store, data} = instance;
+      return data.$selection && this.isSelected(store, data.$selection.record, data.$selection.index);
+   }
+}
+
+Selection.prototype.toggle = false;
+
+Selection.namespace = 'ui.selection.';
+
+class SimpleSelection extends Selection {
+
+   isSelected(store, record, index) {
+      return this.getIsSelectedDelegate(store)(record, index);
+   }
+
+   getIsSelectedDelegate(store) {
+      var selection = this.bind && store.get(this.bind);
+      return (record, index) => record === selection;
+   }
+
+   selectMultiple(store, records, index) {
+      if (this.bind)
+         store.set(this.bind, records[0]);
+   }
+}
+
+class DummySelection extends Selection {
+   isSelected(store, record, index) {
+      return false;
+   }
+
+   selectMultiple() {
+      //dummy
+   }
+
+   selectInstance() {
+      //dummy
+   }
+}
+
+DummySelection.prototype.isDummy = true;
+
+Selection.factory = (name) => {
+   if (typeof name == 'object')
+      return new SimpleSelection(name);
+
+   return new DummySelection();
+};
+

package/src/ui/selection/index.d.ts

@@ -1,3 +1,3 @@
-export * from './Selection';
-export * from './PropertySelection';
-export * from './KeySelection';
+export * from './Selection';
+export * from './PropertySelection';
+export * from './KeySelection';

package/src/ui/selection/index.js

@@ -1,3 +1,3 @@
-export * from './Selection';
-export * from './PropertySelection';
-export * from './KeySelection';
+export * from './Selection';
+export * from './PropertySelection';
+export * from './KeySelection';

package/src/ui/tpl.d.ts

@@ -1,3 +1,3 @@
-import * as Cx from '../core';
-
+import * as Cx from '../core';
+
 export function tpl(text: string) : Cx.Binding;

package/src/ui/tpl.js

@@ -1,5 +1,5 @@
-export function tpl(text) {
-   return {
-      tpl: text
-   }
+export function tpl(text) {
+   return {
+      tpl: text
+   }
 }

package/src/ui/variables.scss

@@ -1,2 +1,2 @@
-
+
 @import "layout/variables";

package/src/util/Component.d.ts

@@ -1,42 +1,42 @@
-import * as Cx from '../core';
-
-interface DecoratorFactory<T> {
-   (t: T): T;
-}
-
-export class Component {
-
-   constructor(config?: Cx.Config);
-
-   init();
-
-   /**
-    * 
-    * @param alias 
-    * @param type 
-    */
-   static alias<T>(alias: string, type: T);
-   static alias<T>(alias: string) : DecoratorFactory<T>;
-
-   /**
-    * 
-    * @param type
-    * @param config
-    * @param more
-    */
-   static create(typeAlias?: any, config?: Cx.Config, more?: Cx.Config): any;
-
-   isComponent: boolean;
-   
-   static isComponentType: boolean;
-   static namespace: string;
-   static autoInit: boolean;
-
-   static factory(alias: string, config: Cx.Config, more?: Cx.Config) : Component;
-
-}
-
-
-export function createComponentFactory(factory, meta);
-
+import * as Cx from '../core';
+
+interface DecoratorFactory<T> {
+   (t: T): T;
+}
+
+export class Component {
+
+   constructor(config?: Cx.Config);
+
+   init();
+
+   /**
+    * 
+    * @param alias 
+    * @param type 
+    */
+   static alias<T>(alias: string, type: T);
+   static alias<T>(alias: string) : DecoratorFactory<T>;
+
+   /**
+    * 
+    * @param type
+    * @param config
+    * @param more
+    */
+   static create(typeAlias?: any, config?: Cx.Config, more?: Cx.Config): any;
+
+   isComponent: boolean;
+   
+   static isComponentType: boolean;
+   static namespace: string;
+   static autoInit: boolean;
+
+   static factory(alias: string, config: Cx.Config, more?: Cx.Config) : Component;
+
+}
+
+
+export function createComponentFactory(factory, meta);
+
 export function isComponentFactory(factory: any): boolean;

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,9 +1,9 @@
-
-export class Console {
-
-   static log();
-
-   static warn();
-
-}
-
+
+export class Console {
+
+   static log();
+
+   static warn();
+
+}
+

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;
+