cx 26.3.9 → 26.4.0

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,157 +1,157 @@
-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[];
-   form?: {
-      invalid?: boolean;
-      files?: { name: string }[];
-   };
-}
-
-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("allows access to properties of optional object properties", () => {
-      let model = createAccessorModelProxy<Model>();
-      // form is optional, but we should still be able to access its properties
-      assert.strictEqual(model.form.toString(), "form");
-      assert.strictEqual(model.form.invalid.toString(), "form.invalid");
-      assert.strictEqual(model.form.files.toString(), "form.files");
-   });
-
-   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[];
+   form?: {
+      invalid?: boolean;
+      files?: { name: string }[];
+   };
+}
+
+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("allows access to properties of optional object properties", () => {
+      let model = createAccessorModelProxy<Model>();
+      // form is optional, but we should still be able to access its properties
+      assert.strictEqual(model.form.toString(), "form");
+      assert.strictEqual(model.form.invalid.toString(), "form.invalid");
+      assert.strictEqual(model.form.files.toString(), "form.files");
+   });
+
+   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/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);
+   });
+});