cx 24.4.3 → 24.4.4

package/src/ui/ContentResolver.js

@@ -1,78 +1,78 @@
-import {PureContainer} from './PureContainer';
-import {isPromise} from '../util/isPromise';
-
-export class ContentResolver extends PureContainer {
-   declareData() {
-      return super.declareData(...arguments, {
-         params: {structured: true},
-         loading: undefined
-      })
-   }
-
-   init() {
-      super.init();
-      this.initialItems = this.layout ? this.layout.items : this.items;
-      this.clear();
-   }
-
-   initInstance(context, instance) {
-      instance.content = this.initialItems;
-      instance.cachedParams = {}; //unique value which will never pass the equality check
-   }
-
-   prepareData(context, instance) {
-      let {data} = instance;
-
-      if (data.params !== instance.cachedParams && this.onResolve) {
-         instance.cachedParams = data.params;
-         let content = instance.invoke("onResolve", data.params, instance);
-         if (isPromise(content)) {
-            instance.set('loading', true);
-            this.setContent(instance, null);
-            content.then(cnt => {
-               this.setContent(instance, cnt);
-               instance.setState({cacheBuster: {}});
-               instance.set('loading', false);
-            })
-         }
-         else
-            this.setContent(instance, content);
-      }
-   }
-
-   setContent(instance, content) {
-      if (content) {
-         this.clear();
-         switch (this.mode) {
-            case 'prepend':
-               this.add(content);
-               this.add(this.initialItems);
-               break;
-
-            case 'append':
-               this.add(this.initialItems);
-               this.add(content);
-               break;
-
-            case "replace":
-               this.add(content);
-               break;
-         }
-         instance.content = this.layout ? this.layout.items : this.items;
-         this.clear();
-      }
-      else
-         instance.content = this.initialItems;
-   }
-
-   explore(context, instance) {
-      //a little bit hacky
-      if (this.layout)
-         this.layout.items = instance.content;
-      else
-         this.items = instance.content;
-      super.explore(context, instance);
-   }
-}
-
-ContentResolver.prototype.mode = 'replace';
+import {PureContainer} from './PureContainer';
+import {isPromise} from '../util/isPromise';
+
+export class ContentResolver extends PureContainer {
+   declareData() {
+      return super.declareData(...arguments, {
+         params: {structured: true},
+         loading: undefined
+      })
+   }
+
+   init() {
+      super.init();
+      this.initialItems = this.layout ? this.layout.items : this.items;
+      this.clear();
+   }
+
+   initInstance(context, instance) {
+      instance.content = this.initialItems;
+      instance.cachedParams = {}; //unique value which will never pass the equality check
+   }
+
+   prepareData(context, instance) {
+      let {data} = instance;
+
+      if (data.params !== instance.cachedParams && this.onResolve) {
+         instance.cachedParams = data.params;
+         let content = instance.invoke("onResolve", data.params, instance);
+         if (isPromise(content)) {
+            instance.set('loading', true);
+            this.setContent(instance, null);
+            content.then(cnt => {
+               this.setContent(instance, cnt);
+               instance.setState({cacheBuster: {}});
+               instance.set('loading', false);
+            })
+         }
+         else
+            this.setContent(instance, content);
+      }
+   }
+
+   setContent(instance, content) {
+      if (content) {
+         this.clear();
+         switch (this.mode) {
+            case 'prepend':
+               this.add(content);
+               this.add(this.initialItems);
+               break;
+
+            case 'append':
+               this.add(this.initialItems);
+               this.add(content);
+               break;
+
+            case "replace":
+               this.add(content);
+               break;
+         }
+         instance.content = this.layout ? this.layout.items : this.items;
+         this.clear();
+      }
+      else
+         instance.content = this.initialItems;
+   }
+
+   explore(context, instance) {
+      //a little bit hacky
+      if (this.layout)
+         this.layout.items = instance.content;
+      else
+         this.items = instance.content;
+      super.explore(context, instance);
+   }
+}
+
+ContentResolver.prototype.mode = 'replace';

package/src/ui/Controller.js

@@ -1,114 +1,114 @@
-import { computable } from "../data/computable";
-import { Component } from "../util/Component";
-import { isArray } from "../util/isArray";
-import { isFunction } from "../util/isFunction";
-import { StoreProxy } from "../data/StoreProxy";
-
-const computablePrefix = "computable-";
-const triggerPrefix = "trigger-";
-
-export class Controller extends Component {
-   init(context) {
-      if (!this.initialized) {
-         this.initialized = true;
-         if (this.onInit) this.onInit(context);
-      }
-   }
-
-   explore(context) {
-      let { store } = this.instance;
-      this.store = store; //in rare cases instance may change its store
-
-      if (!this.initialized) {
-         this.init(context);
-         //forgive if the developer forgets to call super.init()
-         this.initialized = true;
-      }
-
-      if (this.computables) {
-         for (let key in this.computables) {
-            let x = this.computables[key];
-            let v = x.selector(store.getData());
-            if (x.type == "computable") store.set(x.name, v);
-         }
-      }
-
-      if (this.onExplore) {
-         this.onExplore(context);
-      }
-   }
-
-   prepare(context) {
-      if (this.onPrepare) {
-         this.onPrepare(context);
-      }
-   }
-
-   cleanup(context) {
-      if (this.onCleanup) {
-         this.onCleanup(context);
-      }
-   }
-
-   addComputable(name, args, callback) {
-      if (!isArray(args)) throw new Error("Second argument to the addComputable method should be an array.");
-      let selector = computable(...args, callback).memoize();
-      if (!this.computables) this.computables = {};
-      this.computables[computablePrefix + name] = { name, selector, type: "computable" };
-   }
-
-   addTrigger(name, args, callback, autoRun) {
-      if (!isArray(args)) throw new Error("Second argument to the addTrigger method should be an array.");
-      let selector = computable(...args, callback).memoize(!autoRun && this.store.getData());
-      if (!this.computables) this.computables = {};
-      this.computables[triggerPrefix + name] = { name, selector, type: "trigger" };
-   }
-
-   removeTrigger(name) {
-      if (this.computables) delete this.computables[triggerPrefix + name];
-   }
-
-   removeComputable(name) {
-      if (this.computables) delete this.computables[computablePrefix + name];
-   }
-
-   invokeParentMethod(methodName, ...args) {
-      let parent = this.instance.parent;
-      return parent.invokeControllerMethod(methodName, ...args);
-   }
-
-   invokeMethod(methodName, ...args) {
-      return this.instance.invokeControllerMethod(methodName, ...args);
-   }
-}
-
-Controller.namespace = "ui.controller.";
-
-Controller.factory = function (alias, config, more) {
-   if (isFunction(alias)) {
-      let cfg = {
-         ...config,
-         ...more,
-      };
-
-      if (cfg.instance) {
-         //in rare cases instance.store may change, so we cannot rely on the store passed through configuration
-         cfg.store = new StoreProxy(() => cfg.instance.store);
-         Object.assign(cfg, cfg.store.getMethods());
-      }
-
-      let result = alias(cfg);
-      if (result instanceof Controller) return result;
-
-      return Controller.create({
-         ...config,
-         ...more,
-         ...result,
-      });
-   }
-
-   return Controller.create({
-      ...config,
-      ...more,
-   });
-};
+import { computable } from "../data/computable";
+import { Component } from "../util/Component";
+import { isArray } from "../util/isArray";
+import { isFunction } from "../util/isFunction";
+import { StoreProxy } from "../data/StoreProxy";
+
+const computablePrefix = "computable-";
+const triggerPrefix = "trigger-";
+
+export class Controller extends Component {
+   init(context) {
+      if (!this.initialized) {
+         this.initialized = true;
+         if (this.onInit) this.onInit(context);
+      }
+   }
+
+   explore(context) {
+      let { store } = this.instance;
+      this.store = store; //in rare cases instance may change its store
+
+      if (!this.initialized) {
+         this.init(context);
+         //forgive if the developer forgets to call super.init()
+         this.initialized = true;
+      }
+
+      if (this.computables) {
+         for (let key in this.computables) {
+            let x = this.computables[key];
+            let v = x.selector(store.getData());
+            if (x.type == "computable") store.set(x.name, v);
+         }
+      }
+
+      if (this.onExplore) {
+         this.onExplore(context);
+      }
+   }
+
+   prepare(context) {
+      if (this.onPrepare) {
+         this.onPrepare(context);
+      }
+   }
+
+   cleanup(context) {
+      if (this.onCleanup) {
+         this.onCleanup(context);
+      }
+   }
+
+   addComputable(name, args, callback) {
+      if (!isArray(args)) throw new Error("Second argument to the addComputable method should be an array.");
+      let selector = computable(...args, callback).memoize();
+      if (!this.computables) this.computables = {};
+      this.computables[computablePrefix + name] = { name, selector, type: "computable" };
+   }
+
+   addTrigger(name, args, callback, autoRun) {
+      if (!isArray(args)) throw new Error("Second argument to the addTrigger method should be an array.");
+      let selector = computable(...args, callback).memoize(!autoRun && this.store.getData());
+      if (!this.computables) this.computables = {};
+      this.computables[triggerPrefix + name] = { name, selector, type: "trigger" };
+   }
+
+   removeTrigger(name) {
+      if (this.computables) delete this.computables[triggerPrefix + name];
+   }
+
+   removeComputable(name) {
+      if (this.computables) delete this.computables[computablePrefix + name];
+   }
+
+   invokeParentMethod(methodName, ...args) {
+      let parent = this.instance.parent;
+      return parent.invokeControllerMethod(methodName, ...args);
+   }
+
+   invokeMethod(methodName, ...args) {
+      return this.instance.invokeControllerMethod(methodName, ...args);
+   }
+}
+
+Controller.namespace = "ui.controller.";
+
+Controller.factory = function (alias, config, more) {
+   if (isFunction(alias)) {
+      let cfg = {
+         ...config,
+         ...more,
+      };
+
+      if (cfg.instance) {
+         //in rare cases instance.store may change, so we cannot rely on the store passed through configuration
+         cfg.store = new StoreProxy(() => cfg.instance.store);
+         Object.assign(cfg, cfg.store.getMethods());
+      }
+
+      let result = alias(cfg);
+      if (result instanceof Controller) return result;
+
+      return Controller.create({
+         ...config,
+         ...more,
+         ...result,
+      });
+   }
+
+   return Controller.create({
+      ...config,
+      ...more,
+   });
+};