cx 26.1.2 → 26.1.4

package/src/data/computable.ts

@@ -1,69 +1,69 @@
-import { Binding } from "./Binding";
-import { isString } from "../util/isString";
-import { isFunction } from "../util/isFunction";
-import { AccessorChain, isAccessorChain } from "./createAccessorModelProxy";
-import { CanMemoize, MemoSelector, Selector } from "./Selector";
-import { Ref } from "./Ref";
-
-export type ComputableSelector<T = any> = string | Selector<T> | AccessorChain<T> | CanMemoize<T>;
-
-// Helper type to infer the value type from a selector, string, or accessor chain
-export type InferSelectorValue<T> =
-   T extends Selector<infer R> ? R : T extends AccessorChain<infer R> ? R : T extends string ? any : never;
-
-// Generic function with proper type inference for selectors
-export function computable<T extends ComputableSelector[], R>(
-   ...args: [...T, (...values: { [K in keyof T]: InferSelectorValue<T[K]> }) => R]
-): MemoSelector<R>;
-
-export function computable(...selectorsAndCompute: any[]): MemoSelector {
-   if (selectorsAndCompute.length == 0)
-      throw new Error("computable requires at least a compute function to be passed in arguments.");
-
-   let compute = selectorsAndCompute[selectorsAndCompute.length - 1];
-   if (typeof compute != "function") throw new Error("Last argument to the computable function should be a function.");
-
-   let inputs: Selector[] = [],
-      a;
-
-   for (let i = 0; i + 1 < selectorsAndCompute.length; i++) {
-      a = selectorsAndCompute[i];
-      if (isString(a) || isAccessorChain(a)) inputs.push(Binding.get(a.toString()).value);
-      else if (a.memoize) inputs.push(a.memoize());
-      else if (isFunction(a)) inputs.push(a);
-      else throw new Error(`Invalid selector type '${typeof a}' received.`);
-   }
-
-   function memoize(warmupData: any) {
-      let lastValue: any,
-         lastArgs = warmupData && inputs.map((s) => s(warmupData));
-
-      return function (data: any) {
-         let dirty = false;
-
-         if (!lastArgs) {
-            lastArgs = Array.from({ length: inputs.length });
-            dirty = true;
-         }
-
-         for (let i = 0; i < inputs.length; i++) {
-            let v = inputs[i](data);
-            if (v === lastArgs[i]) continue;
-            lastArgs[i] = v;
-            dirty = true;
-         }
-
-         if (dirty) lastValue = compute.apply(null, lastArgs);
-
-         return lastValue;
-      };
-   }
-
-   let selector: Selector = (data) =>
-      compute.apply(
-         null,
-         inputs.map((s) => s(data)),
-      );
-   selector.memoize = memoize;
-   return selector as MemoSelector;
-}
+import { Binding } from "./Binding";
+import { isString } from "../util/isString";
+import { isFunction } from "../util/isFunction";
+import { AccessorChain, isAccessorChain } from "./createAccessorModelProxy";
+import { CanMemoize, MemoSelector, Selector } from "./Selector";
+import { Ref } from "./Ref";
+
+export type ComputableSelector<T = any> = string | Selector<T> | AccessorChain<T> | CanMemoize<T>;
+
+// Helper type to infer the value type from a selector, string, or accessor chain
+export type InferSelectorValue<T> =
+   T extends Selector<infer R> ? R : T extends AccessorChain<infer R> ? R : T extends string ? any : never;
+
+// Generic function with proper type inference for selectors
+export function computable<T extends ComputableSelector[], R>(
+   ...args: [...T, (...values: { [K in keyof T]: InferSelectorValue<T[K]> }) => R]
+): MemoSelector<R>;
+
+export function computable(...selectorsAndCompute: any[]): MemoSelector {
+   if (selectorsAndCompute.length == 0)
+      throw new Error("computable requires at least a compute function to be passed in arguments.");
+
+   let compute = selectorsAndCompute[selectorsAndCompute.length - 1];
+   if (typeof compute != "function") throw new Error("Last argument to the computable function should be a function.");
+
+   let inputs: Selector[] = [],
+      a;
+
+   for (let i = 0; i + 1 < selectorsAndCompute.length; i++) {
+      a = selectorsAndCompute[i];
+      if (isString(a) || isAccessorChain(a)) inputs.push(Binding.get(a.toString()).value);
+      else if (a.memoize) inputs.push(a.memoize());
+      else if (isFunction(a)) inputs.push(a);
+      else throw new Error(`Invalid selector type '${typeof a}' received.`);
+   }
+
+   function memoize(warmupData: any) {
+      let lastValue: any,
+         lastArgs = warmupData && inputs.map((s) => s(warmupData));
+
+      return function (data: any) {
+         let dirty = false;
+
+         if (!lastArgs) {
+            lastArgs = Array.from({ length: inputs.length });
+            dirty = true;
+         }
+
+         for (let i = 0; i < inputs.length; i++) {
+            let v = inputs[i](data);
+            if (v === lastArgs[i]) continue;
+            lastArgs[i] = v;
+            dirty = true;
+         }
+
+         if (dirty) lastValue = compute.apply(null, lastArgs);
+
+         return lastValue;
+      };
+   }
+
+   let selector: Selector = (data) =>
+      compute.apply(
+         null,
+         inputs.map((s) => s(data)),
+      );
+   selector.memoize = memoize;
+   return selector as MemoSelector;
+}

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);
+   });
+});