cx 26.0.2 → 26.0.4

package/src/ui/ContentResolver.ts

@@ -1,124 +1,124 @@
-import { PureContainerBase, PureContainerConfig } from "./PureContainer";
-import { isPromise } from "../util/isPromise";
-import { RenderingContext } from "./RenderingContext";
-import { BooleanProp, StructuredProp, ResolveStructuredProp } from "./Prop";
-import { Instance } from "./Instance";
-
-/**
- * Configuration for ContentResolver widget.
- *
- * The params type parameter enables type inference for the onResolve callback:
- * - Literal values (numbers, strings, booleans) preserve their types
- * - AccessorChain<T> resolves to T
- * - Bind/Tpl/Expr resolve to any (type cannot be determined at compile time)
- *
- * @example
- * ```typescript
- * <ContentResolver
- *    params={{
- *       count: 42,           // number
- *       name: model.user.name // AccessorChain<string> -> string
- *    }}
- *    onResolve={(params) => {
- *       // params.count is number, params.name is string
- *    }}
- * />
- * ```
- */
-export interface ContentResolverConfig<P extends StructuredProp = StructuredProp> extends PureContainerConfig {
-   /** Parameters that trigger content resolution when changed. */
-   params?: P;
-
-   /**
-    * Callback function that resolves content based on params. Can return content directly or a Promise.
-    * The params type is inferred from the params property - literal values and AccessorChain<T>
-    * preserve their types, while bindings (bind/tpl/expr) resolve to `any`.
-    */
-   onResolve?: string | ((params: ResolveStructuredProp<P>, instance: Instance) => any);
-
-   /** How to combine resolved content with initial content. Default is 'replace'. */
-   mode?: "replace" | "prepend" | "append";
-
-   /** Indicates if content is being loaded. */
-   loading?: BooleanProp;
-}
-
-export class ContentResolver<P extends StructuredProp = StructuredProp> extends PureContainerBase<
-   ContentResolverConfig<P>
-> {
-   constructor(config?: ContentResolverConfig<P>) {
-      super(config);
-   }
-
-   declare mode: "replace" | "prepend" | "append";
-   declare onResolve?: string | ((params: ResolveStructuredProp<P>, instance: Instance) => any);
-   declare initialItems: any;
-
-   declareData(...args: any[]): void {
-      super.declareData(...args, {
-         params: { structured: true },
-         loading: undefined,
-      });
-   }
-
-   init(): void {
-      super.init();
-      this.initialItems = this.layout ? this.layout.items : this.items;
-      this.clear();
-   }
-
-   initInstance(context: RenderingContext, instance: any): void {
-      instance.content = this.initialItems;
-      instance.cachedParams = {}; //unique value which will never pass the equality check
-   }
-
-   prepareData(context: RenderingContext, instance: any): void {
-      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: any) => {
-               this.setContent(instance, cnt);
-               instance.setState({ cacheBuster: {} });
-               instance.set("loading", false);
-            });
-         } else this.setContent(instance, content);
-      }
-   }
-
-   setContent(instance: any, content: any): void {
-      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: RenderingContext, instance: any): void {
-      //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 { PureContainerBase, PureContainerConfig } from "./PureContainer";
+import { isPromise } from "../util/isPromise";
+import { RenderingContext } from "./RenderingContext";
+import { BooleanProp, StructuredProp, ResolveStructuredProp } from "./Prop";
+import { Instance } from "./Instance";
+
+/**
+ * Configuration for ContentResolver widget.
+ *
+ * The params type parameter enables type inference for the onResolve callback:
+ * - Literal values (numbers, strings, booleans) preserve their types
+ * - AccessorChain<T> resolves to T
+ * - Bind/Tpl/Expr resolve to any (type cannot be determined at compile time)
+ *
+ * @example
+ * ```typescript
+ * <ContentResolver
+ *    params={{
+ *       count: 42,           // number
+ *       name: model.user.name // AccessorChain<string> -> string
+ *    }}
+ *    onResolve={(params) => {
+ *       // params.count is number, params.name is string
+ *    }}
+ * />
+ * ```
+ */
+export interface ContentResolverConfig<P extends StructuredProp = StructuredProp> extends PureContainerConfig {
+   /** Parameters that trigger content resolution when changed. */
+   params?: P;
+
+   /**
+    * Callback function that resolves content based on params. Can return content directly or a Promise.
+    * The params type is inferred from the params property - literal values and AccessorChain<T>
+    * preserve their types, while bindings (bind/tpl/expr) resolve to `any`.
+    */
+   onResolve?: string | ((params: ResolveStructuredProp<P>, instance: Instance) => any);
+
+   /** How to combine resolved content with initial content. Default is 'replace'. */
+   mode?: "replace" | "prepend" | "append";
+
+   /** Indicates if content is being loaded. */
+   loading?: BooleanProp;
+}
+
+export class ContentResolver<P extends StructuredProp = StructuredProp> extends PureContainerBase<
+   ContentResolverConfig<P>
+> {
+   constructor(config?: ContentResolverConfig<P>) {
+      super(config);
+   }
+
+   declare mode: "replace" | "prepend" | "append";
+   declare onResolve?: string | ((params: ResolveStructuredProp<P>, instance: Instance) => any);
+   declare initialItems: any;
+
+   declareData(...args: any[]): void {
+      super.declareData(...args, {
+         params: { structured: true },
+         loading: undefined,
+      });
+   }
+
+   init(): void {
+      super.init();
+      this.initialItems = this.layout ? this.layout.items : this.items;
+      this.clear();
+   }
+
+   initInstance(context: RenderingContext, instance: any): void {
+      instance.content = this.initialItems;
+      instance.cachedParams = {}; //unique value which will never pass the equality check
+   }
+
+   prepareData(context: RenderingContext, instance: any): void {
+      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: any) => {
+               this.setContent(instance, cnt);
+               instance.setState({ cacheBuster: {} });
+               instance.set("loading", false);
+            });
+         } else this.setContent(instance, content);
+      }
+   }
+
+   setContent(instance: any, content: any): void {
+      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: RenderingContext, instance: any): void {
+      //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.ts

@@ -1,189 +1,189 @@
-import { computable, ComputableSelector, InferSelectorValue } from "../data/computable";
-import { Component, ComponentConstructor, ComponentConfigType } from "../util/Component";
-import { isArray } from "../util/isArray";
-import { isFunction } from "../util/isFunction";
-import { StoreProxy } from "../data/StoreProxy";
-import { RenderingContext } from "./RenderingContext";
-import { View, ViewMethods } from "../data/View";
-import { Widget } from "./Widget";
-import { Instance } from "./Instance";
-
-const computablePrefix = "computable-";
-const triggerPrefix = "trigger-";
-
-interface ComputableEntry {
-   name: string;
-   selector: any;
-   type: "computable" | "trigger";
-}
-
-// Controller methods interface for ThisType in config objects
-export interface ControllerMethods {
-   store: View;
-   instance: Instance;
-   widget?: Widget;
-   invokeParentMethod(method: string, ...args: any[]): any;
-   addTrigger<Selectors extends readonly ComputableSelector[]>(
-      name: string,
-      args: [...Selectors],
-      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
-      autoRun?: boolean,
-   ): void;
-   addComputable<Selectors extends readonly ComputableSelector[]>(
-      name: string,
-      args: [...Selectors],
-      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
-   ): void;
-}
-
-export interface BaseControllerConfig {
-   store?: View;
-   instance?: Instance;
-   widget?: Widget;
-
-   onInit?: (context: RenderingContext) => void;
-   onExplore?: (context: RenderingContext) => void;
-   onPrepare?: (context: RenderingContext) => void;
-   onCleanup?: (context: RenderingContext) => void;
-   onDestroy?: () => void;
-}
-
-// Controller config object type with Controller methods AND its own methods available on 'this'
-export type ControllerConfig<T extends BaseControllerConfig = BaseControllerConfig> = T &
-   ThisType<ControllerMethods & T>;
-
-/** Controller factory function type */
-export type ControllerFactory<T extends BaseControllerConfig = BaseControllerConfig> = (
-   config: ViewMethods,
-) => ControllerConfig<T>;
-
-export class Controller extends Component implements ControllerMethods {
-   initialized?: boolean;
-   onInit?(context: RenderingContext): void;
-   onExplore?(context: RenderingContext): void;
-   onPrepare?(context: RenderingContext): void;
-   onCleanup?(context: RenderingContext): void;
-   onDestroy?(): void;
-   declare instance: Instance;
-   declare store: View;
-   declare widget?: Widget;
-   computables?: Record<string, ComputableEntry>;
-
-   constructor(config?: BaseControllerConfig) {
-      super(config);
-   }
-
-   init(context?: RenderingContext): void {
-      if (!this.initialized) {
-         this.initialized = true;
-         if (this.onInit && context) this.onInit(context);
-      }
-   }
-
-   explore(context: RenderingContext): void {
-      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: RenderingContext): void {
-      if (this.onPrepare) {
-         this.onPrepare(context);
-      }
-   }
-
-   cleanup(context: RenderingContext): void {
-      if (this.onCleanup) {
-         this.onCleanup(context);
-      }
-   }
-
-   addComputable<Selectors extends readonly ComputableSelector[]>(
-      name: string,
-      args: [...Selectors],
-      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
-   ): void {
-      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<Selectors extends readonly ComputableSelector[]>(
-      name: string,
-      args: [...Selectors],
-      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
-      autoRun?: boolean,
-   ): void {
-      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: string): void {
-      if (this.computables) delete this.computables[triggerPrefix + name];
-   }
-
-   removeComputable(name: string): void {
-      if (this.computables) delete this.computables[computablePrefix + name];
-   }
-
-   invokeParentMethod(methodName: string, ...args: any[]): any {
-      let parent = this.instance.parent;
-      if (!parent) throw new Error("Cannot invoke a parent controller method as the instance does not have a parent.");
-      return parent.invokeControllerMethod(methodName, ...args);
-   }
-
-   invokeMethod(methodName: string, ...args: any[]): any {
-      return this.instance.invokeControllerMethod(methodName, ...args);
-   }
-}
-
-Controller.namespace = "ui.controller.";
-
-Controller.factory = function (alias: any, config?: any, more?: any) {
-   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, ComputableSelector, InferSelectorValue } from "../data/computable";
+import { Component, ComponentConstructor, ComponentConfigType } from "../util/Component";
+import { isArray } from "../util/isArray";
+import { isFunction } from "../util/isFunction";
+import { StoreProxy } from "../data/StoreProxy";
+import { RenderingContext } from "./RenderingContext";
+import { View, ViewMethods } from "../data/View";
+import { Widget } from "./Widget";
+import { Instance } from "./Instance";
+
+const computablePrefix = "computable-";
+const triggerPrefix = "trigger-";
+
+interface ComputableEntry {
+   name: string;
+   selector: any;
+   type: "computable" | "trigger";
+}
+
+// Controller methods interface for ThisType in config objects
+export interface ControllerMethods {
+   store: View;
+   instance: Instance;
+   widget?: Widget;
+   invokeParentMethod(method: string, ...args: any[]): any;
+   addTrigger<Selectors extends readonly ComputableSelector[]>(
+      name: string,
+      args: [...Selectors],
+      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
+      autoRun?: boolean,
+   ): void;
+   addComputable<Selectors extends readonly ComputableSelector[]>(
+      name: string,
+      args: [...Selectors],
+      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
+   ): void;
+}
+
+export interface BaseControllerConfig {
+   store?: View;
+   instance?: Instance;
+   widget?: Widget;
+
+   onInit?: (context: RenderingContext) => void;
+   onExplore?: (context: RenderingContext) => void;
+   onPrepare?: (context: RenderingContext) => void;
+   onCleanup?: (context: RenderingContext) => void;
+   onDestroy?: () => void;
+}
+
+// Controller config object type with Controller methods AND its own methods available on 'this'
+export type ControllerConfig<T extends BaseControllerConfig = BaseControllerConfig> = T &
+   ThisType<ControllerMethods & T>;
+
+/** Controller factory function type */
+export type ControllerFactory<T extends BaseControllerConfig = BaseControllerConfig> = (
+   config: ViewMethods,
+) => ControllerConfig<T>;
+
+export class Controller extends Component implements ControllerMethods {
+   initialized?: boolean;
+   onInit?(context: RenderingContext): void;
+   onExplore?(context: RenderingContext): void;
+   onPrepare?(context: RenderingContext): void;
+   onCleanup?(context: RenderingContext): void;
+   onDestroy?(): void;
+   declare instance: Instance;
+   declare store: View;
+   declare widget?: Widget;
+   computables?: Record<string, ComputableEntry>;
+
+   constructor(config?: BaseControllerConfig) {
+      super(config);
+   }
+
+   init(context?: RenderingContext): void {
+      if (!this.initialized) {
+         this.initialized = true;
+         if (this.onInit && context) this.onInit(context);
+      }
+   }
+
+   explore(context: RenderingContext): void {
+      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: RenderingContext): void {
+      if (this.onPrepare) {
+         this.onPrepare(context);
+      }
+   }
+
+   cleanup(context: RenderingContext): void {
+      if (this.onCleanup) {
+         this.onCleanup(context);
+      }
+   }
+
+   addComputable<Selectors extends readonly ComputableSelector[]>(
+      name: string,
+      args: [...Selectors],
+      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
+   ): void {
+      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<Selectors extends readonly ComputableSelector[]>(
+      name: string,
+      args: [...Selectors],
+      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
+      autoRun?: boolean,
+   ): void {
+      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: string): void {
+      if (this.computables) delete this.computables[triggerPrefix + name];
+   }
+
+   removeComputable(name: string): void {
+      if (this.computables) delete this.computables[computablePrefix + name];
+   }
+
+   invokeParentMethod(methodName: string, ...args: any[]): any {
+      let parent = this.instance.parent;
+      if (!parent) throw new Error("Cannot invoke a parent controller method as the instance does not have a parent.");
+      return parent.invokeControllerMethod(methodName, ...args);
+   }
+
+   invokeMethod(methodName: string, ...args: any[]): any {
+      return this.instance.invokeControllerMethod(methodName, ...args);
+   }
+}
+
+Controller.namespace = "ui.controller.";
+
+Controller.factory = function (alias: any, config?: any, more?: any) {
+   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,
+   });
+};