cx 26.0.12 → 26.0.13

package/src/ui/ContentResolver.ts

@@ -1,7 +1,7 @@
 import { PureContainerBase, PureContainerConfig } from "./PureContainer";
 import { isPromise } from "../util/isPromise";
 import { RenderingContext } from "./RenderingContext";
-import { BooleanProp, StructuredProp, ResolveStructuredProp } from "./Prop";
+import { BooleanProp, StructuredProp, ResolvePropType } from "./Prop";
 import { Instance } from "./Instance";
 
 /**
@@ -11,9 +11,11 @@ import { Instance } from "./Instance";
  * - 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)
+ * - Structured props (objects) have each property resolved individually
  *
  * @example
  * ```typescript
+ * // Structured params (object)
  * <ContentResolver
  *    params={{
  *       count: 42,           // number
@@ -23,10 +25,18 @@ import { Instance } from "./Instance";
  *       // params.count is number, params.name is string
  *    }}
  * />
+ *
+ * // Simple param (single value)
+ * <ContentResolver
+ *    params={model.user.name}  // AccessorChain<string>
+ *    onResolve={(name) => {
+ *       // name is string
+ *    }}
+ * />
  * ```
  */
-export interface ContentResolverConfig<P extends StructuredProp = StructuredProp> extends PureContainerConfig {
-   /** Parameters that trigger content resolution when changed. */
+export interface ContentResolverConfig<P = StructuredProp> extends PureContainerConfig {
+   /** Parameters that trigger content resolution when changed. Can be a structured object or a single Prop. */
    params?: P;
 
    /**
@@ -34,7 +44,7 @@ export interface ContentResolverConfig<P extends StructuredProp = StructuredProp
     * 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);
+   onResolve?: string | ((params: ResolvePropType<P>, instance: Instance) => any);
 
    /** How to combine resolved content with initial content. Default is 'replace'. */
    mode?: "replace" | "prepend" | "append";
@@ -43,15 +53,13 @@ export interface ContentResolverConfig<P extends StructuredProp = StructuredProp
    loading?: BooleanProp;
 }
 
-export class ContentResolver<P extends StructuredProp = StructuredProp> extends PureContainerBase<
-   ContentResolverConfig<P>
-> {
+export class ContentResolver<P = 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 onResolve?: string | ((params: ResolvePropType<P>, instance: Instance) => any);
    declare initialItems: any;
 
    declareData(...args: any[]): void {

package/src/ui/Controller.ts

@@ -7,6 +7,7 @@ import { RenderingContext } from "./RenderingContext";
 import { View, ViewMethods } from "../data/View";
 import { Widget } from "./Widget";
 import { Instance } from "./Instance";
+import { AccessorChain } from "../data/createAccessorModelProxy";
 
 const computablePrefix = "computable-";
 const triggerPrefix = "trigger-";
@@ -29,6 +30,11 @@ export interface ControllerMethods {
       callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
       autoRun?: boolean,
    ): void;
+   addComputable<T, Selectors extends readonly ComputableSelector[]>(
+      name: AccessorChain<T>,
+      args: [...Selectors],
+      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => T,
+   ): void;
    addComputable<Selectors extends readonly ComputableSelector[]>(
       name: string,
       args: [...Selectors],
@@ -115,15 +121,22 @@ export class Controller<D = any> extends Component implements ControllerMethods
       }
    }
 
+   addComputable<T, Selectors extends readonly ComputableSelector[]>(
+      name: AccessorChain<T>,
+      args: [...Selectors],
+      callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => T,
+   ): void;
    addComputable<Selectors extends readonly ComputableSelector[]>(
       name: string,
       args: [...Selectors],
       callback: (...values: { [K in keyof Selectors]: InferSelectorValue<Selectors[K]> }) => any,
-   ): void {
+   ): void;
+   addComputable(name: string | AccessorChain<any>, args: ComputableSelector[], callback: (...values: any[]) => 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" };
+      let nameStr = String(name);
+      this.computables[computablePrefix + nameStr] = { name: nameStr, selector, type: "computable" };
    }
 
    addTrigger<Selectors extends readonly ComputableSelector[]>(

package/src/ui/Culture.ts

@@ -1,159 +1,159 @@
-// @ts-expect-error
-import { NumberCulture, DateTimeCulture } from "intl-io";
-import { Localization } from "./Localization";
-import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
-import { invalidateExpressionCache } from "../data/Expression";
-import { invalidateStringTemplateCache } from "../data/StringTemplate";
-import { defaultCompare } from "../data/defaultCompare";
-import { Console } from "../util/Console";
-
-export interface CultureInfo {
-   culture?: string;
-   numberCulture?: string | null;
-   dateTimeCulture?: string | null;
-   defaultCurrency?: string;
-   dateEncoding?: (date: Date) => string;
-   timezone?: string | null;
-}
-
-export interface ResolvedCultureInfo {
-   culture: string;
-   numberCulture?: string | null;
-   dateTimeCulture?: string | null;
-   cache: any;
-   defaultCurrency: string;
-   dateEncoding: (date: Date) => string;
-   timezone?: string | null;
-}
-
-let stack: ResolvedCultureInfo[] = [
-   {
-      culture: "en",
-      numberCulture: null,
-      dateTimeCulture: null,
-      cache: {},
-      defaultCurrency: "USD",
-      dateEncoding: (date: Date) => date.toISOString(),
-      timezone: null,
-   },
-];
-
-export function getDefaultCulture(): ResolvedCultureInfo {
-   return stack[0];
-}
-
-export function getCurrentCulture(): ResolvedCultureInfo {
-   return stack[stack.length - 1];
-}
-
-export function getCurrentCultureCache(): any {
-   return getCurrentCulture().cache;
-}
-
-export function pushCulture(cultureInfo: ResolvedCultureInfo): void {
-   stack.push(cultureInfo);
-}
-
-export function createCulture(cultureSpecs: Partial<CultureInfo>): ResolvedCultureInfo {
-   let current = getCurrentCulture();
-   let info: ResolvedCultureInfo = {
-      culture: current.culture,
-      dateEncoding: current.dateEncoding,
-      defaultCurrency: current.defaultCurrency,
-      cache: {},
-   };
-   for (let key in cultureSpecs) {
-      if (!(cultureSpecs as any)[key]) continue;
-      (info as any)[key] = (cultureSpecs as any)[key];
-   }
-   return info;
-}
-
-export function popCulture(cultureSpecs?: CultureInfo): CultureInfo | undefined {
-   if (stack.length == 1) throw new Error("Cannot pop the last culture object.");
-   if (cultureSpecs && stack[stack.length - 1] !== cultureSpecs) {
-      Console.warn("Popped culture object does not match the current one.");
-   }
-   return stack.pop();
-}
-
-export class Culture {
-   static setCulture(cultureCode: string): void {
-      let cultureSpecs = getDefaultCulture();
-      cultureSpecs.culture = cultureCode;
-      cultureSpecs.cache = {};
-      Localization.setCulture(cultureCode);
-      this.invalidateCache();
-   }
-
-   static setNumberCulture(cultureCode: string): void {
-      let cultureSpecs = getDefaultCulture();
-      cultureSpecs.numberCulture = cultureCode;
-      delete cultureSpecs.cache.numberCulture;
-      this.invalidateCache();
-   }
-
-   static setDateTimeCulture(cultureCode: string): void {
-      let cultureSpecs = getDefaultCulture();
-      cultureSpecs.dateTimeCulture = cultureCode;
-      delete cultureSpecs.cache.dateTimeCulture;
-      this.invalidateCache();
-   }
-
-   static setDefaultCurrency(currencyCode: string): void {
-      let cultureSpecs = getDefaultCulture();
-      cultureSpecs.defaultCurrency = currencyCode;
-      this.invalidateCache();
-   }
-
-   static setDefaultTimezone(timezone: string): void {
-      let cultureSpecs = getDefaultCulture();
-      cultureSpecs.timezone = timezone;
-      this.invalidateCache();
-   }
-
-   static setDefaultDateEncoding(encoding: (date: Date) => string): void {
-      let cultureSpecs = getDefaultCulture();
-      cultureSpecs.dateEncoding = encoding;
-      this.invalidateCache();
-   }
-
-   static invalidateCache(): void {
-      GlobalCacheIdentifier.change();
-      invalidateExpressionCache();
-      invalidateStringTemplateCache();
-   }
-
-   static get defaultCurrency(): string | undefined {
-      return getCurrentCulture().defaultCurrency;
-   }
-
-   static get culture(): string | undefined {
-      return getCurrentCulture().culture;
-   }
-
-   static getNumberCulture(): NumberCulture {
-      let { cache, numberCulture, culture } = getCurrentCulture();
-      if (!cache!.numberCulture) cache!.numberCulture = new NumberCulture(numberCulture ?? culture);
-      return cache!.numberCulture;
-   }
-
-   static getDateTimeCulture(): DateTimeCulture {
-      let { cache, dateTimeCulture, culture, timezone } = getCurrentCulture();
-      if (!cache!.dateTimeCulture)
-         cache!.dateTimeCulture = new DateTimeCulture(dateTimeCulture ?? culture, {
-            defaultTimezone: timezone,
-         });
-      return cache!.dateTimeCulture;
-   }
-
-   static getDefaultDateEncoding(): (date: Date) => string {
-      return getCurrentCulture().dateEncoding;
-   }
-
-   static getComparer(options?: Intl.CollatorOptions): (a: any, b: any) => number {
-      let { culture } = getCurrentCulture();
-      if (typeof Intl.Collator != "undefined") return new Intl.Collator(culture, options).compare;
-      return defaultCompare;
-   }
-}
+// @ts-expect-error
+import { NumberCulture, DateTimeCulture } from "intl-io";
+import { Localization } from "./Localization";
+import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
+import { invalidateExpressionCache } from "../data/Expression";
+import { invalidateStringTemplateCache } from "../data/StringTemplate";
+import { defaultCompare } from "../data/defaultCompare";
+import { Console } from "../util/Console";
+
+export interface CultureInfo {
+   culture?: string;
+   numberCulture?: string | null;
+   dateTimeCulture?: string | null;
+   defaultCurrency?: string;
+   dateEncoding?: (date: Date) => string;
+   timezone?: string | null;
+}
+
+export interface ResolvedCultureInfo {
+   culture: string;
+   numberCulture?: string | null;
+   dateTimeCulture?: string | null;
+   cache: any;
+   defaultCurrency: string;
+   dateEncoding: (date: Date) => string;
+   timezone?: string | null;
+}
+
+let stack: ResolvedCultureInfo[] = [
+   {
+      culture: "en",
+      numberCulture: null,
+      dateTimeCulture: null,
+      cache: {},
+      defaultCurrency: "USD",
+      dateEncoding: (date: Date) => date.toISOString(),
+      timezone: null,
+   },
+];
+
+export function getDefaultCulture(): ResolvedCultureInfo {
+   return stack[0];
+}
+
+export function getCurrentCulture(): ResolvedCultureInfo {
+   return stack[stack.length - 1];
+}
+
+export function getCurrentCultureCache(): any {
+   return getCurrentCulture().cache;
+}
+
+export function pushCulture(cultureInfo: ResolvedCultureInfo): void {
+   stack.push(cultureInfo);
+}
+
+export function createCulture(cultureSpecs: Partial<CultureInfo>): ResolvedCultureInfo {
+   let current = getCurrentCulture();
+   let info: ResolvedCultureInfo = {
+      culture: current.culture,
+      dateEncoding: current.dateEncoding,
+      defaultCurrency: current.defaultCurrency,
+      cache: {},
+   };
+   for (let key in cultureSpecs) {
+      if (!(cultureSpecs as any)[key]) continue;
+      (info as any)[key] = (cultureSpecs as any)[key];
+   }
+   return info;
+}
+
+export function popCulture(cultureSpecs?: CultureInfo): CultureInfo | undefined {
+   if (stack.length == 1) throw new Error("Cannot pop the last culture object.");
+   if (cultureSpecs && stack[stack.length - 1] !== cultureSpecs) {
+      Console.warn("Popped culture object does not match the current one.");
+   }
+   return stack.pop();
+}
+
+export class Culture {
+   static setCulture(cultureCode: string): void {
+      let cultureSpecs = getDefaultCulture();
+      cultureSpecs.culture = cultureCode;
+      cultureSpecs.cache = {};
+      Localization.setCulture(cultureCode);
+      this.invalidateCache();
+   }
+
+   static setNumberCulture(cultureCode: string): void {
+      let cultureSpecs = getDefaultCulture();
+      cultureSpecs.numberCulture = cultureCode;
+      delete cultureSpecs.cache.numberCulture;
+      this.invalidateCache();
+   }
+
+   static setDateTimeCulture(cultureCode: string): void {
+      let cultureSpecs = getDefaultCulture();
+      cultureSpecs.dateTimeCulture = cultureCode;
+      delete cultureSpecs.cache.dateTimeCulture;
+      this.invalidateCache();
+   }
+
+   static setDefaultCurrency(currencyCode: string): void {
+      let cultureSpecs = getDefaultCulture();
+      cultureSpecs.defaultCurrency = currencyCode;
+      this.invalidateCache();
+   }
+
+   static setDefaultTimezone(timezone: string): void {
+      let cultureSpecs = getDefaultCulture();
+      cultureSpecs.timezone = timezone;
+      this.invalidateCache();
+   }
+
+   static setDefaultDateEncoding(encoding: (date: Date) => string): void {
+      let cultureSpecs = getDefaultCulture();
+      cultureSpecs.dateEncoding = encoding;
+      this.invalidateCache();
+   }
+
+   static invalidateCache(): void {
+      GlobalCacheIdentifier.change();
+      invalidateExpressionCache();
+      invalidateStringTemplateCache();
+   }
+
+   static get defaultCurrency(): string | undefined {
+      return getCurrentCulture().defaultCurrency;
+   }
+
+   static get culture(): string | undefined {
+      return getCurrentCulture().culture;
+   }
+
+   static getNumberCulture(): NumberCulture {
+      let { cache, numberCulture, culture } = getCurrentCulture();
+      if (!cache!.numberCulture) cache!.numberCulture = new NumberCulture(numberCulture ?? culture);
+      return cache!.numberCulture;
+   }
+
+   static getDateTimeCulture(): DateTimeCulture {
+      let { cache, dateTimeCulture, culture, timezone } = getCurrentCulture();
+      if (!cache!.dateTimeCulture)
+         cache!.dateTimeCulture = new DateTimeCulture(dateTimeCulture ?? culture, {
+            defaultTimezone: timezone,
+         });
+      return cache!.dateTimeCulture;
+   }
+
+   static getDefaultDateEncoding(): (date: Date) => string {
+      return getCurrentCulture().dateEncoding;
+   }
+
+   static getComparer(options?: Intl.CollatorOptions): (a: any, b: any) => number {
+      let { culture } = getCurrentCulture();
+      if (typeof Intl.Collator != "undefined") return new Intl.Collator(culture, options).compare;
+      return defaultCompare;
+   }
+}

package/src/ui/DataProxy.ts

@@ -1,55 +1,55 @@
-import { NestedDataView } from "../data/NestedDataView";
-import { UseParentLayout } from "../ui/layout/UseParentLayout";
-import { PureContainerBase, PureContainerConfig } from "./PureContainer";
-import { StructuredInstanceDataAccessor } from "./StructuredInstanceDataAccessor";
-import { StructuredProp, Bind } from "./Prop";
-
-export interface DataProxyConfig extends PureContainerConfig {
-   /** Data object with computed values to be exposed in the local store. */
-   data?: StructuredProp;
-
-   /** Binding to a value to be exposed under the `alias` name. */
-   value?: Bind;
-
-   /** Alias name under which `value` is exposed in the local store. */
-   alias?: string;
-
-   /** Indicate that parent store data should not be mutated. */
-   immutable?: boolean;
-
-   /** Indicate that local store data should not be mutated. */
-   sealed?: boolean;
-}
-
-export class DataProxy extends PureContainerBase<DataProxyConfig> {
-   declare data?: any;
-   declare alias?: string;
-   declare value?: any;
-   declare immutable: boolean;
-   declare sealed: boolean;
-
-   init() {
-      if (!this.data) this.data = {};
-
-      if (this.alias) this.data[this.alias] = this.value;
-
-      super.init();
-   }
-
-   initInstance(context: any, instance: any) {
-      instance.store = new NestedDataView({
-         store: instance.parentStore,
-         nestedData: new StructuredInstanceDataAccessor({ instance, data: this.data, useParentStore: true }),
-         immutable: this.immutable,
-         sealed: this.sealed,
-      });
-      super.initInstance(context, instance);
-   }
-
-   applyParentStore(instance: any) {
-      instance.store.setStore(instance.parentStore);
-   }
-}
-
-DataProxy.prototype.immutable = false;
-DataProxy.prototype.sealed = false;
+import { NestedDataView } from "../data/NestedDataView";
+import { UseParentLayout } from "../ui/layout/UseParentLayout";
+import { PureContainerBase, PureContainerConfig } from "./PureContainer";
+import { StructuredInstanceDataAccessor } from "./StructuredInstanceDataAccessor";
+import { StructuredProp, Bind } from "./Prop";
+
+export interface DataProxyConfig extends PureContainerConfig {
+   /** Data object with computed values to be exposed in the local store. */
+   data?: StructuredProp;
+
+   /** Binding to a value to be exposed under the `alias` name. */
+   value?: Bind;
+
+   /** Alias name under which `value` is exposed in the local store. */
+   alias?: string;
+
+   /** Indicate that parent store data should not be mutated. */
+   immutable?: boolean;
+
+   /** Indicate that local store data should not be mutated. */
+   sealed?: boolean;
+}
+
+export class DataProxy extends PureContainerBase<DataProxyConfig> {
+   declare data?: any;
+   declare alias?: string;
+   declare value?: any;
+   declare immutable: boolean;
+   declare sealed: boolean;
+
+   init() {
+      if (!this.data) this.data = {};
+
+      if (this.alias) this.data[this.alias] = this.value;
+
+      super.init();
+   }
+
+   initInstance(context: any, instance: any) {
+      instance.store = new NestedDataView({
+         store: instance.parentStore,
+         nestedData: new StructuredInstanceDataAccessor({ instance, data: this.data, useParentStore: true }),
+         immutable: this.immutable,
+         sealed: this.sealed,
+      });
+      super.initInstance(context, instance);
+   }
+
+   applyParentStore(instance: any) {
+      instance.store.setStore(instance.parentStore);
+   }
+}
+
+DataProxy.prototype.immutable = false;
+DataProxy.prototype.sealed = false;