cx 26.1.0 → 26.1.2

package/src/data/createAccessorModelProxy.spec.tsx

@@ -1,145 +1,145 @@
-import { createAccessorModelProxy, AccessorChain } from "./createAccessorModelProxy";
-import { Prop, ResolvePropType } from "../ui/Prop";
-import { Widget, WidgetConfig } from "../ui/Widget";
-import assert from "assert";
-
-interface Model {
-   firstName: string;
-   address: {
-      city: string;
-      streetNumber: number;
-   };
-   "@crazy": string;
-   users: User[];
-}
-
-interface User {
-   id: number;
-   name: string;
-   email: string;
-}
-
-describe("createAccessorModelProxy", () => {
-   it("generates correct paths", () => {
-      let model = createAccessorModelProxy<Model>();
-      assert.strictEqual(model.firstName.toString(), "firstName");
-      assert.strictEqual(model.address.toString(), "address");
-      assert.strictEqual(model.address.city.toString(), "address.city");
-   });
-
-   it("can be used in string templates", () => {
-      let model = createAccessorModelProxy<Model>();
-      assert.strictEqual("address.city", `${model.address.city}`);
-      assert.strictEqual("address.city", "" + model.address.city);
-      assert.strictEqual("address.city.suffix", model.address.city + ".suffix");
-   });
-
-   it("nameOf returns name of the last prop ", () => {
-      let model = createAccessorModelProxy<Model>();
-      assert.strictEqual(model.firstName.nameOf(), "firstName");
-      assert.strictEqual(model.address.nameOf(), "address");
-      assert.strictEqual(model.address.city.nameOf(), "city");
-      assert.strictEqual(model.address.nameOf(), "address");
-
-      let { streetNumber, city } = model.address;
-      assert.strictEqual(streetNumber.nameOf(), "streetNumber");
-      assert.strictEqual(city.nameOf(), "city");
-   });
-
-   it("allows non-standard property identifiers ", () => {
-      let model = createAccessorModelProxy<Model>();
-      assert.strictEqual(model["@crazy"].nameOf(), "@crazy");
-   });
-
-   it("AccessorChain<any> allows access to any property", () => {
-      // When using an untyped model (any), all property access should be allowed
-      let model = createAccessorModelProxy<any>();
-
-      // These should all be valid - no TypeScript errors
-      assert.strictEqual(model.foo.toString(), "foo");
-      assert.strictEqual(model.bar.baz.toString(), "bar.baz");
-      assert.strictEqual(model.deeply.nested.property.toString(), "deeply.nested.property");
-      assert.strictEqual(model.anyName.anyChild.anyGrandchild.toString(), "anyName.anyChild.anyGrandchild");
-   });
-
-   it("ResolvePropType extracts correct types from AccessorChain", () => {
-      let model = createAccessorModelProxy<Model>();
-
-      // ResolvePropType should extract the inner type from AccessorChain
-      type ResolvedString = ResolvePropType<typeof model.firstName>;
-      type ResolvedNumber = ResolvePropType<typeof model.address.streetNumber>;
-      type ResolvedUsers = ResolvePropType<typeof model.users>;
-
-      // These assignments verify the types are correctly inferred
-      // If types are wrong, TypeScript will error
-      const str: ResolvedString = "test";
-      const num: ResolvedNumber = 42;
-      const users: ResolvedUsers = [{ id: 1, name: "John", email: "john@example.com" }];
-
-      // Verify array element type is preserved
-      type UserArray = ResolvePropType<AccessorChain<User[]>>;
-      const userArray: UserArray = [{ id: 1, name: "Test", email: "test@test.com" }];
-
-      // Runtime assertion to make the test meaningful
-      assert.ok(true);
-   });
-
-   it("generic widget infers type from AccessorChain in JSX", () => {
-      let model = createAccessorModelProxy<Model>();
-
-      // Simulates a generic widget config like LookupFieldConfig<TOption>
-      interface GenericWidgetConfig<T = unknown> extends WidgetConfig {
-         items?: AccessorChain<T[]>;
-         onProcess?: (item: T) => void;
-      }
-
-      // Simulates a CxJS widget class
-      class GenericWidget<T = unknown> extends Widget<GenericWidgetConfig<T>> {}
-
-      // T should be inferred as User from model.users (AccessorChain<User[]>)
-      let widget = (
-         <cx>
-            <GenericWidget
-               items={model.users}
-               onProcess={(user) => {
-                  // user should be typed as User
-                  const id: number = user.id;
-                  const name: string = user.name;
-                  const email: string = user.email;
-               }}
-            />
-         </cx>
-      );
-
-      assert.ok(true);
-   });
-
-   it("generic widget infers type from Prop<T[]> in JSX", () => {
-      let model = createAccessorModelProxy<Model>();
-
-      // Uses Prop<T[]> like LookupFieldConfig does
-      interface GenericWidgetConfig<T = unknown> extends WidgetConfig {
-         items?: Prop<T[]>;
-         onProcess?: (item: T) => void;
-      }
-
-      class GenericWidget<T = unknown> extends Widget<GenericWidgetConfig<T>> {}
-
-      // T should be inferred as User from model.users (AccessorChain<User[]>)
-      let widget = (
-         <cx>
-            <GenericWidget
-               items={model.users}
-               onProcess={(user) => {
-                  // user should be typed as User
-                  const id: number = user.id;
-                  const name: string = user.name;
-                  const email: string = user.email;
-               }}
-            />
-         </cx>
-      );
-
-      assert.ok(true);
-   });
-});
+import { createAccessorModelProxy, AccessorChain } from "./createAccessorModelProxy";
+import { Prop, ResolvePropType } from "../ui/Prop";
+import { Widget, WidgetConfig } from "../ui/Widget";
+import assert from "assert";
+
+interface Model {
+   firstName: string;
+   address: {
+      city: string;
+      streetNumber: number;
+   };
+   "@crazy": string;
+   users: User[];
+}
+
+interface User {
+   id: number;
+   name: string;
+   email: string;
+}
+
+describe("createAccessorModelProxy", () => {
+   it("generates correct paths", () => {
+      let model = createAccessorModelProxy<Model>();
+      assert.strictEqual(model.firstName.toString(), "firstName");
+      assert.strictEqual(model.address.toString(), "address");
+      assert.strictEqual(model.address.city.toString(), "address.city");
+   });
+
+   it("can be used in string templates", () => {
+      let model = createAccessorModelProxy<Model>();
+      assert.strictEqual("address.city", `${model.address.city}`);
+      assert.strictEqual("address.city", "" + model.address.city);
+      assert.strictEqual("address.city.suffix", model.address.city + ".suffix");
+   });
+
+   it("nameOf returns name of the last prop ", () => {
+      let model = createAccessorModelProxy<Model>();
+      assert.strictEqual(model.firstName.nameOf(), "firstName");
+      assert.strictEqual(model.address.nameOf(), "address");
+      assert.strictEqual(model.address.city.nameOf(), "city");
+      assert.strictEqual(model.address.nameOf(), "address");
+
+      let { streetNumber, city } = model.address;
+      assert.strictEqual(streetNumber.nameOf(), "streetNumber");
+      assert.strictEqual(city.nameOf(), "city");
+   });
+
+   it("allows non-standard property identifiers ", () => {
+      let model = createAccessorModelProxy<Model>();
+      assert.strictEqual(model["@crazy"].nameOf(), "@crazy");
+   });
+
+   it("AccessorChain<any> allows access to any property", () => {
+      // When using an untyped model (any), all property access should be allowed
+      let model = createAccessorModelProxy<any>();
+
+      // These should all be valid - no TypeScript errors
+      assert.strictEqual(model.foo.toString(), "foo");
+      assert.strictEqual(model.bar.baz.toString(), "bar.baz");
+      assert.strictEqual(model.deeply.nested.property.toString(), "deeply.nested.property");
+      assert.strictEqual(model.anyName.anyChild.anyGrandchild.toString(), "anyName.anyChild.anyGrandchild");
+   });
+
+   it("ResolvePropType extracts correct types from AccessorChain", () => {
+      let model = createAccessorModelProxy<Model>();
+
+      // ResolvePropType should extract the inner type from AccessorChain
+      type ResolvedString = ResolvePropType<typeof model.firstName>;
+      type ResolvedNumber = ResolvePropType<typeof model.address.streetNumber>;
+      type ResolvedUsers = ResolvePropType<typeof model.users>;
+
+      // These assignments verify the types are correctly inferred
+      // If types are wrong, TypeScript will error
+      const str: ResolvedString = "test";
+      const num: ResolvedNumber = 42;
+      const users: ResolvedUsers = [{ id: 1, name: "John", email: "john@example.com" }];
+
+      // Verify array element type is preserved
+      type UserArray = ResolvePropType<AccessorChain<User[]>>;
+      const userArray: UserArray = [{ id: 1, name: "Test", email: "test@test.com" }];
+
+      // Runtime assertion to make the test meaningful
+      assert.ok(true);
+   });
+
+   it("generic widget infers type from AccessorChain in JSX", () => {
+      let model = createAccessorModelProxy<Model>();
+
+      // Simulates a generic widget config like LookupFieldConfig<TOption>
+      interface GenericWidgetConfig<T = unknown> extends WidgetConfig {
+         items?: AccessorChain<T[]>;
+         onProcess?: (item: T) => void;
+      }
+
+      // Simulates a CxJS widget class
+      class GenericWidget<T = unknown> extends Widget<GenericWidgetConfig<T>> {}
+
+      // T should be inferred as User from model.users (AccessorChain<User[]>)
+      let widget = (
+         <cx>
+            <GenericWidget
+               items={model.users}
+               onProcess={(user) => {
+                  // user should be typed as User
+                  const id: number = user.id;
+                  const name: string = user.name;
+                  const email: string = user.email;
+               }}
+            />
+         </cx>
+      );
+
+      assert.ok(true);
+   });
+
+   it("generic widget infers type from Prop<T[]> in JSX", () => {
+      let model = createAccessorModelProxy<Model>();
+
+      // Uses Prop<T[]> like LookupFieldConfig does
+      interface GenericWidgetConfig<T = unknown> extends WidgetConfig {
+         items?: Prop<T[]>;
+         onProcess?: (item: T) => void;
+      }
+
+      class GenericWidget<T = unknown> extends Widget<GenericWidgetConfig<T>> {}
+
+      // T should be inferred as User from model.users (AccessorChain<User[]>)
+      let widget = (
+         <cx>
+            <GenericWidget
+               items={model.users}
+               onProcess={(user) => {
+                  // user should be typed as User
+                  const id: number = user.id;
+                  const name: string = user.name;
+                  const email: string = user.email;
+               }}
+            />
+         </cx>
+      );
+
+      assert.ok(true);
+   });
+});

package/src/data/createAccessorModelProxy.ts

@@ -1,66 +1,66 @@
-interface AccessorChainMethods {
-   toString(): string;
-   valueOf(): unknown;
-   nameOf(): string;
-}
-
-type AccessorChainMap<M extends object> = {
-   [prop in Exclude<keyof M, keyof AccessorChainMethods>]: AccessorChain<M[prop]>;
-};
-
-// Check if a type is `any` using the intersection trick
-type IsAny<T> = 0 extends 1 & T ? true : false;
-
-export type AccessorChain<M> = {
-   toString(): string;
-   valueOf(): M | undefined;
-   nameOf(): string;
-} & (IsAny<M> extends true
-   ? { [key: string]: any } // Allow any property access for `any` type
-   : M extends object
-     ? AccessorChainMap<M>
-     : {});
-
-const emptyFn = () => {};
-
-export function createAccessorModelProxy<M>(chain: string = ""): AccessorChain<M> {
-   let lastOp: string | null = null;
-
-   const proxy = new Proxy(emptyFn, {
-      get: (_, name: string | symbol) => {
-         if (typeof name !== "string") return proxy;
-
-         switch (name) {
-            case "isAccessorChain":
-               return true;
-
-            case "toString":
-            case "valueOf":
-            case "nameOf":
-               lastOp = name;
-               return proxy;
-         }
-
-         let newChain = chain;
-         if (newChain.length > 0) newChain += ".";
-         newChain += name;
-         return createAccessorModelProxy(newChain);
-      },
-
-      apply(): string {
-         switch (lastOp) {
-            case "nameOf":
-               const lastDotIndex = chain.lastIndexOf(".");
-               return lastDotIndex > 0 ? chain.substring(lastDotIndex + 1) : chain;
-
-            default:
-               return chain;
-         }
-      },
-   });
-   return proxy as unknown as AccessorChain<M>;
-}
-
-export function isAccessorChain<M>(value: unknown): value is AccessorChain<M> {
-   return value != null && !!(value as any).isAccessorChain;
-}
+interface AccessorChainMethods {
+   toString(): string;
+   valueOf(): unknown;
+   nameOf(): string;
+}
+
+type AccessorChainMap<M extends object> = {
+   [prop in Exclude<keyof M, keyof AccessorChainMethods>]: AccessorChain<M[prop]>;
+};
+
+// Check if a type is `any` using the intersection trick
+type IsAny<T> = 0 extends 1 & T ? true : false;
+
+export type AccessorChain<M> = {
+   toString(): string;
+   valueOf(): M | undefined;
+   nameOf(): string;
+} & (IsAny<M> extends true
+   ? { [key: string]: any } // Allow any property access for `any` type
+   : M extends object
+     ? AccessorChainMap<M>
+     : {});
+
+const emptyFn = () => {};
+
+export function createAccessorModelProxy<M>(chain: string = ""): AccessorChain<M> {
+   let lastOp: string | null = null;
+
+   const proxy = new Proxy(emptyFn, {
+      get: (_, name: string | symbol) => {
+         if (typeof name !== "string") return proxy;
+
+         switch (name) {
+            case "isAccessorChain":
+               return true;
+
+            case "toString":
+            case "valueOf":
+            case "nameOf":
+               lastOp = name;
+               return proxy;
+         }
+
+         let newChain = chain;
+         if (newChain.length > 0) newChain += ".";
+         newChain += name;
+         return createAccessorModelProxy(newChain);
+      },
+
+      apply(): string {
+         switch (lastOp) {
+            case "nameOf":
+               const lastDotIndex = chain.lastIndexOf(".");
+               return lastDotIndex > 0 ? chain.substring(lastDotIndex + 1) : chain;
+
+            default:
+               return chain;
+         }
+      },
+   });
+   return proxy as unknown as AccessorChain<M>;
+}
+
+export function isAccessorChain<M>(value: unknown): value is AccessorChain<M> {
+   return value != null && !!(value as any).isAccessorChain;
+}

package/src/data/createStructuredSelector.spec.ts

@@ -1,45 +1,45 @@
-import { createStructuredSelector } from "./createStructuredSelector";
-import assert from "assert";
-import { getSelector } from "./getSelector";
-import { computable } from "./computable";
-
-describe("createStructuredSelector", function () {
-   it("works", function () {
-      let structure = {
-         name: getSelector({ bind: "name" }),
-      };
-      let state = { name: "Joe" };
-      let selector = createStructuredSelector(structure);
-      assert.deepEqual(selector(state), { name: "Joe" });
-   });
-
-   it("does not memoize by default", function () {
-      let computes = 0;
-      let structure = {
-         name: computable("name", (name) => {
-            computes++;
-            return name;
-         }),
-      };
-      let state = { name: "Joe" };
-      let selector = createStructuredSelector(structure);
-      assert.deepEqual(selector(state), { name: "Joe" });
-      selector(state);
-      assert.deepEqual(computes, 2);
-   });
-
-   it("supports memoize", function () {
-      let computes = 0;
-      let structure = {
-         name: computable("name", (name) => {
-            computes++;
-            return name;
-         }),
-      };
-      let state = { name: "Joe" };
-      let selector = createStructuredSelector(structure).memoize();
-      assert.deepEqual(selector(state), { name: "Joe" });
-      selector(state);
-      assert.deepEqual(computes, 1);
-   });
-});
+import { createStructuredSelector } from "./createStructuredSelector";
+import assert from "assert";
+import { getSelector } from "./getSelector";
+import { computable } from "./computable";
+
+describe("createStructuredSelector", function () {
+   it("works", function () {
+      let structure = {
+         name: getSelector({ bind: "name" }),
+      };
+      let state = { name: "Joe" };
+      let selector = createStructuredSelector(structure);
+      assert.deepEqual(selector(state), { name: "Joe" });
+   });
+
+   it("does not memoize by default", function () {
+      let computes = 0;
+      let structure = {
+         name: computable("name", (name) => {
+            computes++;
+            return name;
+         }),
+      };
+      let state = { name: "Joe" };
+      let selector = createStructuredSelector(structure);
+      assert.deepEqual(selector(state), { name: "Joe" });
+      selector(state);
+      assert.deepEqual(computes, 2);
+   });
+
+   it("supports memoize", function () {
+      let computes = 0;
+      let structure = {
+         name: computable("name", (name) => {
+            computes++;
+            return name;
+         }),
+      };
+      let state = { name: "Joe" };
+      let selector = createStructuredSelector(structure).memoize();
+      assert.deepEqual(selector(state), { name: "Joe" });
+      selector(state);
+      assert.deepEqual(computes, 1);
+   });
+});

package/src/data/createStructuredSelector.ts

@@ -1,62 +1,62 @@
-import { MemoSelector, Selector } from "./Selector";
-
-export interface StructuredSelectorConfig {
-   [prop: string]: Selector;
-}
-
-// Helper type to infer result type from selector config
-type InferStructuredSelectorResult<T extends StructuredSelectorConfig, C = {}> = {
-   [K in keyof T]: T[K] extends Selector<infer R> ? R : any;
-} & C;
-
-export function createStructuredSelector<S extends StructuredSelectorConfig, C extends Record<string, any> = {}>(
-   selector: S,
-   constants?: C,
-): MemoSelector<InferStructuredSelectorResult<S, C>> {
-   let keys = Object.keys(selector);
-   constants = constants ?? ({} as C);
-   if (keys.length == 0) {
-      let result: Selector = () => constants;
-      result.memoize = () => result;
-      return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
-   }
-
-   function memoize() {
-      let lastResult: Record<string, any> = Object.assign({}, constants);
-
-      let memoizedSelectors: Record<string, Selector> = {};
-
-      keys.forEach((key) => {
-         memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
-         lastResult[key] = undefined;
-      });
-
-      return function (data: any) {
-         let result = lastResult,
-            k,
-            v,
-            i;
-         for (i = 0; i < keys.length; i++) {
-            k = keys[i];
-            v = memoizedSelectors[k](data);
-            if (result === lastResult) {
-               if (v === lastResult[k]) continue;
-               result = Object.assign({}, lastResult);
-            }
-            result[k] = v;
-         }
-         return (lastResult = result);
-      };
-   }
-
-   let result: Selector = function evaluate(data: any) {
-      let result: Record<string, any> = Object.assign({}, constants);
-      for (let i = 0; i < keys.length; i++) {
-         result[keys[i]] = selector[keys[i]](data);
-      }
-      return result;
-   };
-
-   result.memoize = memoize;
-   return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
-}
+import { MemoSelector, Selector } from "./Selector";
+
+export interface StructuredSelectorConfig {
+   [prop: string]: Selector;
+}
+
+// Helper type to infer result type from selector config
+type InferStructuredSelectorResult<T extends StructuredSelectorConfig, C = {}> = {
+   [K in keyof T]: T[K] extends Selector<infer R> ? R : any;
+} & C;
+
+export function createStructuredSelector<S extends StructuredSelectorConfig, C extends Record<string, any> = {}>(
+   selector: S,
+   constants?: C,
+): MemoSelector<InferStructuredSelectorResult<S, C>> {
+   let keys = Object.keys(selector);
+   constants = constants ?? ({} as C);
+   if (keys.length == 0) {
+      let result: Selector = () => constants;
+      result.memoize = () => result;
+      return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
+   }
+
+   function memoize() {
+      let lastResult: Record<string, any> = Object.assign({}, constants);
+
+      let memoizedSelectors: Record<string, Selector> = {};
+
+      keys.forEach((key) => {
+         memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
+         lastResult[key] = undefined;
+      });
+
+      return function (data: any) {
+         let result = lastResult,
+            k,
+            v,
+            i;
+         for (i = 0; i < keys.length; i++) {
+            k = keys[i];
+            v = memoizedSelectors[k](data);
+            if (result === lastResult) {
+               if (v === lastResult[k]) continue;
+               result = Object.assign({}, lastResult);
+            }
+            result[k] = v;
+         }
+         return (lastResult = result);
+      };
+   }
+
+   let result: Selector = function evaluate(data: any) {
+      let result: Record<string, any> = Object.assign({}, constants);
+      for (let i = 0; i < keys.length; i++) {
+         result[keys[i]] = selector[keys[i]](data);
+      }
+      return result;
+   };
+
+   result.memoize = memoize;
+   return result as MemoSelector<InferStructuredSelectorResult<S, C>>;
+}

package/src/data/defaultCompare.ts

@@ -1,15 +1,15 @@
-export function defaultCompare(av: any, bv: any): number {
-   if (av == null) {
-      if (bv == null)
-         return 0;
-      return -1;
-   }
-
-   if (bv == null || av > bv)
-      return 1;
-
-   if (av < bv)
-      return -1;
-
-   return 0;
+export function defaultCompare(av: any, bv: any): number {
+   if (av == null) {
+      if (bv == null)
+         return 0;
+      return -1;
+   }
+
+   if (bv == null || av > bv)
+      return 1;
+
+   if (av < bv)
+      return -1;
+
+   return 0;
 }