cx 26.1.1 → 26.1.2

package/src/ui/IsolatedScope.spec.tsx

@@ -1,62 +1,62 @@
-import { Store } from "../data/Store";
-import { createTestRenderer, act } from "../util/test/createTestRenderer";
-import assert from "assert";
-import { IsolatedScope } from "./IsolatedScope";
-import { bind } from "./bind";
-
-describe("IsolatedScope", () => {
-   it("prevents multiple re-renders", async () => {
-      let list: any[] = [];
-      let widget = (
-         <cx>
-            <IsolatedScope
-               data={{
-                  value: { bind: "value" },
-               }}
-            >
-               <span
-                  text={bind("value")}
-                  onExplore={(context, { store }) => {
-                     list.push(store.get("value"));
-                  }}
-               />
-            </IsolatedScope>
-         </cx>
-      );
-
-      let store = new Store({
-         data: {
-            value: "bad",
-         },
-      });
-
-      const component = await createTestRenderer(store, widget);
-
-      let tree = component.toJSON();
-      assert.deepEqual(list, ["bad"]);
-      assert.deepEqual(tree, {
-         type: "span",
-         props: {},
-         children: ["bad"],
-      });
-
-      //component should not re-render if unrelated data changes
-      await act(async () => {
-         store.set("dummy", "dummy");
-      });
-      tree = component.toJSON();
-      assert.deepEqual(list, ["bad"]);
-
-      //component should not re-render if unrelated data changes
-      await act(async () => {
-         store.set("value", "good");
-      });
-      tree = component.toJSON();
-      assert.deepEqual(list, ["bad", "good"]);
-      assert.deepEqual(tree, {
-         type: "span",
-         props: {},
-         children: ["good"],
-      });
-   });
-});
+import { Store } from "../data/Store";
+import { createTestRenderer, act } from "../util/test/createTestRenderer";
+import assert from "assert";
+import { IsolatedScope } from "./IsolatedScope";
+import { bind } from "./bind";
+
+describe("IsolatedScope", () => {
+   it("prevents multiple re-renders", async () => {
+      let list: any[] = [];
+      let widget = (
+         <cx>
+            <IsolatedScope
+               data={{
+                  value: { bind: "value" },
+               }}
+            >
+               <span
+                  text={bind("value")}
+                  onExplore={(context, { store }) => {
+                     list.push(store.get("value"));
+                  }}
+               />
+            </IsolatedScope>
+         </cx>
+      );
+
+      let store = new Store({
+         data: {
+            value: "bad",
+         },
+      });
+
+      const component = await createTestRenderer(store, widget);
+
+      let tree = component.toJSON();
+      assert.deepEqual(list, ["bad"]);
+      assert.deepEqual(tree, {
+         type: "span",
+         props: {},
+         children: ["bad"],
+      });
+
+      //component should not re-render if unrelated data changes
+      await act(async () => {
+         store.set("dummy", "dummy");
+      });
+      tree = component.toJSON();
+      assert.deepEqual(list, ["bad"]);
+
+      //component should not re-render if unrelated data changes
+      await act(async () => {
+         store.set("value", "good");
+      });
+      tree = component.toJSON();
+      assert.deepEqual(list, ["bad", "good"]);
+      assert.deepEqual(tree, {
+         type: "span",
+         props: {},
+         children: ["good"],
+      });
+   });
+});

package/src/ui/IsolatedScope.ts

@@ -1,50 +1,50 @@
-import { PureContainerBase, PureContainerConfig } from "./PureContainer";
-import { isArray } from "../util/isArray";
-import { Instance } from "./Instance";
-import { StructuredProp } from "./Prop";
-
-export interface IsolatedScopeConfig extends PureContainerConfig {
-   /**
-    * A single binding path or a list of paths to be monitored for changes.
-    * Use `bind` as a shorthand for defining the `data` object.
-    */
-   bind?: string | string[];
-
-   /** Data object selector. The children will update only if `data` change. */
-   data?: StructuredProp;
-}
-
-export class IsolatedScope<
-   Config extends IsolatedScopeConfig = IsolatedScopeConfig,
-   InstanceType extends Instance = Instance,
-> extends PureContainerBase<Config, InstanceType> {
-   declare bind?: string | string[];
-   declare data?: StructuredProp;
-
-   declareData(...args: any[]) {
-      return super.declareData(...args, {
-         data: { structured: true },
-      });
-   }
-
-   init() {
-      if (typeof this.bind === "string") this.data = { bind: this.bind };
-      else if (isArray(this.bind)) {
-         let data: Record<string, any> = {};
-         this.bind.forEach((x, i) => {
-            data[String(i)] = { bind: x };
-         });
-         this.data = data;
-      }
-      super.init();
-   }
-
-   explore(context: any, instance: any) {
-      if (instance.shouldUpdate) {
-         super.explore(context, instance);
-      } else if (instance.children) {
-         // mark children to prevent sweeping them away
-         for (let i = 0; i < instance.children.length; i++) instance.instanceCache.addChild(instance.children[i]);
-      }
-   }
-}
+import { PureContainerBase, PureContainerConfig } from "./PureContainer";
+import { isArray } from "../util/isArray";
+import { Instance } from "./Instance";
+import { StructuredProp } from "./Prop";
+
+export interface IsolatedScopeConfig extends PureContainerConfig {
+   /**
+    * A single binding path or a list of paths to be monitored for changes.
+    * Use `bind` as a shorthand for defining the `data` object.
+    */
+   bind?: string | string[];
+
+   /** Data object selector. The children will update only if `data` change. */
+   data?: StructuredProp;
+}
+
+export class IsolatedScope<
+   Config extends IsolatedScopeConfig = IsolatedScopeConfig,
+   InstanceType extends Instance = Instance,
+> extends PureContainerBase<Config, InstanceType> {
+   declare bind?: string | string[];
+   declare data?: StructuredProp;
+
+   declareData(...args: any[]) {
+      return super.declareData(...args, {
+         data: { structured: true },
+      });
+   }
+
+   init() {
+      if (typeof this.bind === "string") this.data = { bind: this.bind };
+      else if (isArray(this.bind)) {
+         let data: Record<string, any> = {};
+         this.bind.forEach((x, i) => {
+            data[String(i)] = { bind: x };
+         });
+         this.data = data;
+      }
+      super.init();
+   }
+
+   explore(context: any, instance: any) {
+      if (instance.shouldUpdate) {
+         super.explore(context, instance);
+      } else if (instance.children) {
+         // mark children to prevent sweeping them away
+         for (let i = 0; i < instance.children.length; i++) instance.instanceCache.addChild(instance.children[i]);
+      }
+   }
+}

package/src/ui/Localization.ts

@@ -1,70 +1,70 @@
-let contents: any = {};
-let localizations: any = {};
-let overrides: any = {};
-let defaults: any = {};
-let trackDefaults = false;
-
-export class Localization {
-   static register(key: string) {
-      return (type: any) => {
-         this.registerPrototype(key, type);
-         return type;
-      }
-   }
-
-   static registerPrototype(key: string, type: any) {
-      contents[key] = type.prototype;
-      if (overrides[key])
-         this.override(key, overrides[key]);
-   }
-
-   static trackDefaults() {
-      trackDefaults = true;
-   }
-
-   static restoreDefaults() {
-      for (let type in defaults) {
-         let proto = contents[type];
-         if (!proto)
-            continue;
-         let d = defaults[type];
-         for (let key in d)
-            proto[key] = d[key];
-      }
-      defaults = {};
-   }
-
-   static override(key: string, values: any) {
-      overrides[key] = values;
-      let p = contents[key];
-      if (p) {
-         if (trackDefaults && !defaults[key]) {
-            let d: any = defaults[key] = {};
-            for (let key in values)
-               d[key] = p[key];
-         }
-         Object.assign(p, values);
-      }
-   }
-
-   static localize(culture: string, key: string, values: any) {
-      let l = localizations[culture];
-      if (!l)
-         l = localizations[culture] = {};
-      l[key] = {
-         ...l[key],
-         ...values
-      };
-   }
-
-   static setCulture(culture: string) {
-      var l = localizations[culture];
-      if (l) {
-         for (var key in l) {
-            var content = contents[key];
-            if (content)
-               Object.assign(content, l[key]);
-         }
-      }
-   }
-}
+let contents: any = {};
+let localizations: any = {};
+let overrides: any = {};
+let defaults: any = {};
+let trackDefaults = false;
+
+export class Localization {
+   static register(key: string) {
+      return (type: any) => {
+         this.registerPrototype(key, type);
+         return type;
+      }
+   }
+
+   static registerPrototype(key: string, type: any) {
+      contents[key] = type.prototype;
+      if (overrides[key])
+         this.override(key, overrides[key]);
+   }
+
+   static trackDefaults() {
+      trackDefaults = true;
+   }
+
+   static restoreDefaults() {
+      for (let type in defaults) {
+         let proto = contents[type];
+         if (!proto)
+            continue;
+         let d = defaults[type];
+         for (let key in d)
+            proto[key] = d[key];
+      }
+      defaults = {};
+   }
+
+   static override(key: string, values: any) {
+      overrides[key] = values;
+      let p = contents[key];
+      if (p) {
+         if (trackDefaults && !defaults[key]) {
+            let d: any = defaults[key] = {};
+            for (let key in values)
+               d[key] = p[key];
+         }
+         Object.assign(p, values);
+      }
+   }
+
+   static localize(culture: string, key: string, values: any) {
+      let l = localizations[culture];
+      if (!l)
+         l = localizations[culture] = {};
+      l[key] = {
+         ...l[key],
+         ...values
+      };
+   }
+
+   static setCulture(culture: string) {
+      var l = localizations[culture];
+      if (l) {
+         for (var key in l) {
+            var content = contents[key];
+            if (content)
+               Object.assign(content, l[key]);
+         }
+      }
+   }
+}

package/src/ui/Prop.ts

@@ -1,140 +1,140 @@
-import { Selector } from "../data/Selector";
-import { AccessorChain } from "../data/createAccessorModelProxy";
-
-export type Bind = {
-   bind: string;
-   defaultValue?: any;
-   throttle?: number;
-   debounce?: number;
-};
-
-export type Tpl = {
-   tpl: string;
-};
-
-export type Expr = {
-   expr: string;
-   set?: (value: any, instance?: any) => boolean;
-   throttle?: number;
-   debounce?: number;
-};
-
-export type Binding = Bind | Tpl | Expr;
-
-export type GetSet<T> = {
-   get: Selector<T>;
-   set?: (value: T, instance?: any) => boolean;
-   throttle?: number;
-   debounce?: number;
-};
-
-export interface StructuredSelector {
-   [prop: string]: Selector<any>;
-}
-
-export type Prop<T> = T | Binding | Selector<T> | AccessorChain<T> | GetSet<T>;
-
-export type WritableProp<T> = Bind | AccessorChain<T>;
-
-export interface DataRecord {
-   [prop: string]: any;
-}
-
-export interface Config {
-   [prop: string]: any;
-}
-
-export interface StructuredProp {
-   [prop: string]: Prop<any>;
-}
-
-/**
- * Utility type that extracts the resolved value type from a Prop<T>.
- * Used to derive the runtime type of structured props.
- */
-export type ResolveProp<P> =
-   P extends Selector<infer T>
-      ? T
-      : P extends AccessorChain<infer T>
-        ? T
-        : P extends GetSet<infer T>
-          ? T
-          : P extends Bind
-            ? any
-            : P extends Tpl
-              ? string
-              : P extends Expr
-                ? any
-                : P;
-
-/**
- * Utility type that resolves a structured prop object to its runtime value types.
- * Transforms { name: StringProp, count: NumberProp } to { name: string, count: number }
- */
-export type ResolveStructuredPropType<S> = {
-   [K in keyof S]: ResolveProp<S[K]>;
-};
-
-/**
- * Resolves the runtime value type from either a Prop<T> or a StructuredProp.
- * Use this for generic widgets like ContentResolver and Validator where the
- * input can be either a single prop or a structured object.
- *
- * - For Prop<T> (Selector, AccessorChain, GetSet), resolves to T
- * - For bindings (Bind, Tpl, Expr), resolves to any/string/any
- * - For structured objects, recursively resolves each property via ResolveStructuredProp
- * - For literal values, returns them as-is
- */
-export type ResolvePropType<P> =
-   P extends Selector<infer T>
-      ? T
-      : P extends AccessorChain<infer T>
-        ? T
-        : P extends GetSet<infer T>
-          ? T
-          : P extends Bind
-            ? any
-            : P extends Tpl
-              ? string
-              : P extends Expr
-                ? any
-                : P extends object
-                  ? ResolveStructuredPropType<P>
-                  : P;
-
-/**
- * Generic structured prop type that provides type safety for params and their resolved values.
- * Use with ContentResolver and similar widgets to type the onResolve callback params.
- */
-export type TypedStructuredProp<T extends Record<string, any>> = {
-   [K in keyof T]: Prop<T[K]>;
-};
-
-export type StringProp = Prop<string>;
-export type StyleProp = Prop<string | React.CSSProperties> | StructuredProp;
-export type NumberProp = Prop<number>;
-export type BooleanProp = Prop<boolean>;
-export type ClassProp = Prop<string> | StructuredProp;
-export type RecordsProp = Prop<DataRecord[]>;
-export type SortersProp = Prop<Sorter[]>;
-export type UnknownProp = Prop<unknown>;
-export type ModProp = StringProp | StructuredProp;
-
-export type RecordAlias = string | { toString(): string };
-
-export type SortDirection = "ASC" | "DESC";
-
-export interface Sorter {
-   field?: string;
-   value?: (record: DataRecord) => any;
-   direction: SortDirection;
-}
-
-export interface CollatorOptions {
-   localeMatcher?: "lookup" | "best fit";
-   usage?: "sort" | "search";
-   sensitivity?: "base" | "accent" | "case" | "variant";
-   ignorePunctuation?: boolean;
-   numeric?: boolean;
-   caseFirst?: "upper" | "lower" | "false";
-}
+import { Selector } from "../data/Selector";
+import { AccessorChain } from "../data/createAccessorModelProxy";
+
+export type Bind = {
+   bind: string;
+   defaultValue?: any;
+   throttle?: number;
+   debounce?: number;
+};
+
+export type Tpl = {
+   tpl: string;
+};
+
+export type Expr = {
+   expr: string;
+   set?: (value: any, instance?: any) => boolean;
+   throttle?: number;
+   debounce?: number;
+};
+
+export type Binding = Bind | Tpl | Expr;
+
+export type GetSet<T> = {
+   get: Selector<T>;
+   set?: (value: T, instance?: any) => boolean;
+   throttle?: number;
+   debounce?: number;
+};
+
+export interface StructuredSelector {
+   [prop: string]: Selector<any>;
+}
+
+export type Prop<T> = T | Binding | Selector<T> | AccessorChain<T> | GetSet<T>;
+
+export type WritableProp<T> = Bind | AccessorChain<T>;
+
+export interface DataRecord {
+   [prop: string]: any;
+}
+
+export interface Config {
+   [prop: string]: any;
+}
+
+export interface StructuredProp {
+   [prop: string]: Prop<any>;
+}
+
+/**
+ * Utility type that extracts the resolved value type from a Prop<T>.
+ * Used to derive the runtime type of structured props.
+ */
+export type ResolveProp<P> =
+   P extends Selector<infer T>
+      ? T
+      : P extends AccessorChain<infer T>
+        ? T
+        : P extends GetSet<infer T>
+          ? T
+          : P extends Bind
+            ? any
+            : P extends Tpl
+              ? string
+              : P extends Expr
+                ? any
+                : P;
+
+/**
+ * Utility type that resolves a structured prop object to its runtime value types.
+ * Transforms { name: StringProp, count: NumberProp } to { name: string, count: number }
+ */
+export type ResolveStructuredPropType<S> = {
+   [K in keyof S]: ResolveProp<S[K]>;
+};
+
+/**
+ * Resolves the runtime value type from either a Prop<T> or a StructuredProp.
+ * Use this for generic widgets like ContentResolver and Validator where the
+ * input can be either a single prop or a structured object.
+ *
+ * - For Prop<T> (Selector, AccessorChain, GetSet), resolves to T
+ * - For bindings (Bind, Tpl, Expr), resolves to any/string/any
+ * - For structured objects, recursively resolves each property via ResolveStructuredProp
+ * - For literal values, returns them as-is
+ */
+export type ResolvePropType<P> =
+   P extends Selector<infer T>
+      ? T
+      : P extends AccessorChain<infer T>
+        ? T
+        : P extends GetSet<infer T>
+          ? T
+          : P extends Bind
+            ? any
+            : P extends Tpl
+              ? string
+              : P extends Expr
+                ? any
+                : P extends object
+                  ? ResolveStructuredPropType<P>
+                  : P;
+
+/**
+ * Generic structured prop type that provides type safety for params and their resolved values.
+ * Use with ContentResolver and similar widgets to type the onResolve callback params.
+ */
+export type TypedStructuredProp<T extends Record<string, any>> = {
+   [K in keyof T]: Prop<T[K]>;
+};
+
+export type StringProp = Prop<string>;
+export type StyleProp = Prop<string | React.CSSProperties> | StructuredProp;
+export type NumberProp = Prop<number>;
+export type BooleanProp = Prop<boolean>;
+export type ClassProp = Prop<string> | StructuredProp;
+export type RecordsProp = Prop<DataRecord[]>;
+export type SortersProp = Prop<Sorter[]>;
+export type UnknownProp = Prop<unknown>;
+export type ModProp = StringProp | StructuredProp;
+
+export type RecordAlias = string | { toString(): string };
+
+export type SortDirection = "ASC" | "DESC";
+
+export interface Sorter {
+   field?: string;
+   value?: (record: DataRecord) => any;
+   direction: SortDirection;
+}
+
+export interface CollatorOptions {
+   localeMatcher?: "lookup" | "best fit";
+   usage?: "sort" | "search";
+   sensitivity?: "base" | "accent" | "case" | "variant";
+   ignorePunctuation?: boolean;
+   numeric?: boolean;
+   caseFirst?: "upper" | "lower" | "false";
+}