cx 26.1.3 → 26.1.4

package/src/hooks/invokeCallback.spec.tsx

@@ -1,59 +1,59 @@
-import assert from "assert";
-import { Store } from "../data/Store";
-import { createFunctionalComponent } from "../ui/createFunctionalComponent";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { invokeCallback } from "./invokeCallback";
-
-describe("invokeCallback", () => {
-   it("works with functions", async () => {
-      const FComp = createFunctionalComponent(({ onTest }: { onTest: (v: any) => void }) => {
-         invokeCallback(null!, onTest, "works");
-         return (
-            <cx>
-               <div />
-            </cx>
-         );
-      });
-
-      let store = new Store();
-      let value;
-      const component = await createTestRenderer(store, {
-         type: FComp,
-         onTest: (v: any) => {
-            value = v;
-         },
-      });
-
-      component.toJSON();
-      assert.equal(value, "works");
-   });
-
-   it("works with controller methods", async () => {
-      const FComp = createFunctionalComponent(({ onTest }: { onTest: (v: any) => void }) => {
-         return (
-            <cx>
-               <div
-                  onExplore={(context, instance) => {
-                     invokeCallback(instance, onTest, "works");
-                  }}
-               />
-            </cx>
-         );
-      });
-
-      let store = new Store();
-      let value;
-      const component = await createTestRenderer(store, {
-         type: FComp,
-         onTest: "onTest",
-         controller: {
-            onTest(v: any) {
-               value = v;
-            },
-         },
-      });
-
-      component.toJSON();
-      assert.equal(value, "works");
-   });
-});
+import assert from "assert";
+import { Store } from "../data/Store";
+import { createFunctionalComponent } from "../ui/createFunctionalComponent";
+import { createTestRenderer } from "../util/test/createTestRenderer";
+import { invokeCallback } from "./invokeCallback";
+
+describe("invokeCallback", () => {
+   it("works with functions", async () => {
+      const FComp = createFunctionalComponent(({ onTest }: { onTest: (v: any) => void }) => {
+         invokeCallback(null!, onTest, "works");
+         return (
+            <cx>
+               <div />
+            </cx>
+         );
+      });
+
+      let store = new Store();
+      let value;
+      const component = await createTestRenderer(store, {
+         type: FComp,
+         onTest: (v: any) => {
+            value = v;
+         },
+      });
+
+      component.toJSON();
+      assert.equal(value, "works");
+   });
+
+   it("works with controller methods", async () => {
+      const FComp = createFunctionalComponent(({ onTest }: { onTest: (v: any) => void }) => {
+         return (
+            <cx>
+               <div
+                  onExplore={(context, instance) => {
+                     invokeCallback(instance, onTest, "works");
+                  }}
+               />
+            </cx>
+         );
+      });
+
+      let store = new Store();
+      let value;
+      const component = await createTestRenderer(store, {
+         type: FComp,
+         onTest: "onTest",
+         controller: {
+            onTest(v: any) {
+               value = v;
+            },
+         },
+      });
+
+      component.toJSON();
+      assert.equal(value, "works");
+   });
+});

package/src/hooks/invokeCallback.ts

@@ -1,8 +1,8 @@
-import { isFunction } from "../util/isFunction";
-import { isString } from "../util/isString";
-import { Instance } from "../ui/Instance";
-
-export function invokeCallback(instance: Instance, callback: string | ((...args: any[]) => any), ...args: any[]): any {
-   if (isString(callback)) return instance.invokeControllerMethod(callback, ...args);
-   if (isFunction(callback)) return callback(...args);
-}
+import { isFunction } from "../util/isFunction";
+import { isString } from "../util/isString";
+import { Instance } from "../ui/Instance";
+
+export function invokeCallback(instance: Instance, callback: string | ((...args: any[]) => any), ...args: any[]): any {
+   if (isString(callback)) return instance.invokeControllerMethod(callback, ...args);
+   if (isFunction(callback)) return callback(...args);
+}

package/src/hooks/resolveCallback.spec.tsx

@@ -1,71 +1,71 @@
-import assert from "assert";
-import { Store } from "../data/Store";
-import { createFunctionalComponent } from "../ui/createFunctionalComponent";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { resolveCallback } from "./resolveCallback";
-
-describe("resolveCallback", () => {
-   it("works with functions", async () => {
-      const FComp = createFunctionalComponent(({ onTest }: { onTest: (value: string) => void }) => {
-         let callback = resolveCallback(onTest);
-         assert(typeof callback === "function");
-         callback("works");
-         return (
-            <cx>
-               <div />
-            </cx>
-         );
-      });
-
-      let store = new Store();
-      let value;
-      const component = await createTestRenderer(
-         store,
-         <cx>
-            <FComp
-               onTest={(v: string) => {
-                  value = v;
-               }}
-            />
-         </cx>,
-      );
-
-      component.toJSON();
-      assert.equal(value, "works");
-   });
-
-   it("works with controller methods", async () => {
-      const FComp = createFunctionalComponent(({ onTest }: { onTest: string | ((value: string) => void) }) => {
-         let callback = resolveCallback(onTest);
-         assert(typeof callback === "function");
-         return (
-            <cx>
-               <div
-                  onInit={() => {
-                     callback("works");
-                  }}
-               />
-            </cx>
-         );
-      });
-
-      let store = new Store();
-      let value;
-      const component = await createTestRenderer(
-         store,
-         <cx>
-            <FComp
-               onTest="onTest"
-               controller={{
-                  onTest(v: string) {
-                     value = v;
-                  },
-               }}
-            />
-         </cx>,
-      );
-
-      component.toJSON();
-      assert.equal(value, "works");
-   });
-});
+import assert from "assert";
+import { Store } from "../data/Store";
+import { createFunctionalComponent } from "../ui/createFunctionalComponent";
+import { createTestRenderer } from "../util/test/createTestRenderer";
+import { resolveCallback } from "./resolveCallback";
+
+describe("resolveCallback", () => {
+   it("works with functions", async () => {
+      const FComp = createFunctionalComponent(({ onTest }: { onTest: (value: string) => void }) => {
+         let callback = resolveCallback(onTest);
+         assert(typeof callback === "function");
+         callback("works");
+         return (
+            <cx>
+               <div />
+            </cx>
+         );
+      });
+
+      let store = new Store();
+      let value;
+      const component = await createTestRenderer(
+         store,
+         <cx>
+            <FComp
+               onTest={(v: string) => {
+                  value = v;
+               }}
+            />
+         </cx>,
+      );
+
+      component.toJSON();
+      assert.equal(value, "works");
+   });
+
+   it("works with controller methods", async () => {
+      const FComp = createFunctionalComponent(({ onTest }: { onTest: string | ((value: string) => void) }) => {
+         let callback = resolveCallback(onTest);
+         assert(typeof callback === "function");
+         return (
+            <cx>
+               <div
+                  onInit={() => {
+                     callback("works");
+                  }}
+               />
+            </cx>
+         );
+      });
+
+      let store = new Store();
+      let value;
+      const component = await createTestRenderer(
+         store,
+         <cx>
+            <FComp
+               onTest="onTest"
+               controller={{
+                  onTest(v: string) {
+                     value = v;
+                  },
+               }}
+            />
+         </cx>,
+      );
+
+      component.toJSON();
+      assert.equal(value, "works");
+   });
+});

package/src/hooks/resolveCallback.ts

@@ -1,16 +1,16 @@
-import { isFunction } from "../util/isFunction";
-import { isString } from "../util/isString";
-import { getCurrentInstance } from "../ui/createFunctionalComponent";
-import { Instance } from "../ui/Instance";
-
-export function resolveCallback(
-   callback: string | ((...args: any[]) => any),
-   instance?: Instance,
-): ((...args: any[]) => any) | undefined {
-   if (isFunction(callback)) return callback;
-   if (isString(callback)) {
-      if (!instance) instance = getCurrentInstance();
-      return (...args: any[]) => instance!.invokeControllerMethod(callback, ...args);
-   }
-   return undefined;
-}
+import { isFunction } from "../util/isFunction";
+import { isString } from "../util/isString";
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+import { Instance } from "../ui/Instance";
+
+export function resolveCallback(
+   callback: string | ((...args: any[]) => any),
+   instance?: Instance,
+): ((...args: any[]) => any) | undefined {
+   if (isFunction(callback)) return callback;
+   if (isString(callback)) {
+      if (!instance) instance = getCurrentInstance();
+      return (...args: any[]) => instance!.invokeControllerMethod(callback, ...args);
+   }
+   return undefined;
+}

package/src/hooks/store.spec.tsx

@@ -1,67 +1,67 @@
-import assert from "assert";
-import { Prop } from "../ui/Prop";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { computable } from "../data";
-import { Store } from "../data/Store";
-import { createFunctionalComponent } from "../ui/createFunctionalComponent";
-import { ref } from "./store";
-
-describe("ref", () => {
-   it("allows store references in functional components", async () => {
-      const FComp = createFunctionalComponent(({}) => {
-         let testValue = ref({ bind: "x", defaultValue: 10 });
-         return (
-            <cx>
-               <div text={testValue} />
-            </cx>
-         );
-      });
-
-      let store = new Store();
-
-      const component = await createTestRenderer(store, FComp);
-
-      let tree = component.toJSON();
-      assert.deepEqual(tree, {
-         type: "div",
-         children: ["10"],
-         props: {},
-      });
-   });
-
-   it("can be used to adapt any prop passed to a functional component", async () => {
-      const FComp = createFunctionalComponent(({ value }: { value: Prop<any> }) => {
-         return (
-            <cx>
-               <div text={computable(ref(value), (value) => `x${value}`)} />
-            </cx>
-         );
-      });
-
-      let store = new Store({ data: { value: 100 } });
-
-      async function test(value: Prop<any>, expectation: any) {
-         const component = await createTestRenderer(store, <FComp value={value} />);
-         let tree = component.toJSON();
-         assert.deepEqual(tree, {
-            type: "div",
-            children: [expectation],
-            props: {},
-         });
-      }
-
-      await test({ bind: "value" }, "x100");
-      await test({ expr: "{value}" }, "x100");
-      await test({ tpl: "{value:n;2}" }, "x100.00");
-      await test(200, "x200");
-      await test(() => 500, "x500");
-      await test(
-         computable("value", (value: string) => value + 100),
-         "x200",
-      );
-      await test(null, "xnull");
-      await test(undefined, "xundefined");
-      await test(0, "x0");
-      await test(false, "xfalse");
-   });
-});
+import assert from "assert";
+import { Prop } from "../ui/Prop";
+import { createTestRenderer } from "../util/test/createTestRenderer";
+import { computable } from "../data";
+import { Store } from "../data/Store";
+import { createFunctionalComponent } from "../ui/createFunctionalComponent";
+import { ref } from "./store";
+
+describe("ref", () => {
+   it("allows store references in functional components", async () => {
+      const FComp = createFunctionalComponent(({}) => {
+         let testValue = ref({ bind: "x", defaultValue: 10 });
+         return (
+            <cx>
+               <div text={testValue} />
+            </cx>
+         );
+      });
+
+      let store = new Store();
+
+      const component = await createTestRenderer(store, FComp);
+
+      let tree = component.toJSON();
+      assert.deepEqual(tree, {
+         type: "div",
+         children: ["10"],
+         props: {},
+      });
+   });
+
+   it("can be used to adapt any prop passed to a functional component", async () => {
+      const FComp = createFunctionalComponent(({ value }: { value: Prop<any> }) => {
+         return (
+            <cx>
+               <div text={computable(ref(value), (value) => `x${value}`)} />
+            </cx>
+         );
+      });
+
+      let store = new Store({ data: { value: 100 } });
+
+      async function test(value: Prop<any>, expectation: any) {
+         const component = await createTestRenderer(store, <FComp value={value} />);
+         let tree = component.toJSON();
+         assert.deepEqual(tree, {
+            type: "div",
+            children: [expectation],
+            props: {},
+         });
+      }
+
+      await test({ bind: "value" }, "x100");
+      await test({ expr: "{value}" }, "x100");
+      await test({ tpl: "{value:n;2}" }, "x100.00");
+      await test(200, "x200");
+      await test(() => 500, "x500");
+      await test(
+         computable("value", (value: string) => value + 100),
+         "x200",
+      );
+      await test(null, "xnull");
+      await test(undefined, "xundefined");
+      await test(0, "x0");
+      await test(false, "xfalse");
+   });
+});

package/src/hooks/store.ts

@@ -1,46 +1,46 @@
-import { Selector } from "../data/Selector";
-import { BindingObject, isBindingObject } from "../data/Binding";
-import { expression } from "../data/Expression";
-import { getSelector } from "../data/getSelector";
-import { Ref } from "../data/Ref";
-import { stringTemplate } from "../data/StringTemplate";
-import { View } from "../data/View";
-import { getCurrentInstance } from "../ui/createFunctionalComponent";
-import { GetSet, Prop } from "../ui/Prop";
-import { hasFunctionAtKey, hasStringAtKey } from "../util/hasKey";
-import { isObject } from "../util/isObject";
-
-export function useStore(): View {
-   return getCurrentInstance().store;
-}
-
-export function useStoreMethods(): ReturnType<View["getMethods"]> {
-   return getCurrentInstance().store.getMethods();
-}
-
-export type RefInput<T> = Prop<T> | Ref<T>;
-
-export function ref<T = any>(input: BindingObject): GetSet<T>;
-export function ref<T = any>(input: Ref<T>): GetSet<T>;
-export function ref<T = any>(input: Prop<T>): Selector<T>;
-export function ref<T = any>(info: unknown): GetSet<T> | Selector<T> {
-   if (isObject(info)) {
-      if (isBindingObject(info)) return useStore().ref(info.bind, info.defaultValue);
-      if (hasFunctionAtKey(info, "get")) return info as unknown as Ref<T>;
-      if (hasFunctionAtKey(info, "memoize")) return info as unknown as Selector<T>;
-      if (hasStringAtKey(info, "expr")) {
-         let store = useStore();
-         let selector = expression(info.expr).memoize();
-         return new Ref<T>({ get: () => selector(store.getData()), set: (info as any).set }) as unknown as Selector<T>;
-      }
-      if (hasStringAtKey(info, "tpl")) {
-         let store = useStore();
-         let selector = stringTemplate(info.tpl).memoize();
-         return new Ref<T>({
-            get: () => selector(store.getData()) as T,
-            set: (info as any).set,
-         }) as unknown as Selector<T>;
-      }
-   }
-   return getSelector(info);
-}
+import { Selector } from "../data/Selector";
+import { BindingObject, isBindingObject } from "../data/Binding";
+import { expression } from "../data/Expression";
+import { getSelector } from "../data/getSelector";
+import { Ref } from "../data/Ref";
+import { stringTemplate } from "../data/StringTemplate";
+import { View } from "../data/View";
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+import { GetSet, Prop } from "../ui/Prop";
+import { hasFunctionAtKey, hasStringAtKey } from "../util/hasKey";
+import { isObject } from "../util/isObject";
+
+export function useStore(): View {
+   return getCurrentInstance().store;
+}
+
+export function useStoreMethods(): ReturnType<View["getMethods"]> {
+   return getCurrentInstance().store.getMethods();
+}
+
+export type RefInput<T> = Prop<T> | Ref<T>;
+
+export function ref<T = any>(input: BindingObject): GetSet<T>;
+export function ref<T = any>(input: Ref<T>): GetSet<T>;
+export function ref<T = any>(input: Prop<T>): Selector<T>;
+export function ref<T = any>(info: unknown): GetSet<T> | Selector<T> {
+   if (isObject(info)) {
+      if (isBindingObject(info)) return useStore().ref(info.bind, info.defaultValue);
+      if (hasFunctionAtKey(info, "get")) return info as unknown as Ref<T>;
+      if (hasFunctionAtKey(info, "memoize")) return info as unknown as Selector<T>;
+      if (hasStringAtKey(info, "expr")) {
+         let store = useStore();
+         let selector = expression(info.expr).memoize();
+         return new Ref<T>({ get: () => selector(store.getData()), set: (info as any).set }) as unknown as Selector<T>;
+      }
+      if (hasStringAtKey(info, "tpl")) {
+         let store = useStore();
+         let selector = stringTemplate(info.tpl).memoize();
+         return new Ref<T>({
+            get: () => selector(store.getData()) as T,
+            set: (info as any).set,
+         }) as unknown as Selector<T>;
+      }
+   }
+   return getSelector(info);
+}

package/src/hooks/useEffect.ts

@@ -1,14 +1,14 @@
-import { getCurrentInstance } from "../ui/createFunctionalComponent";
-
-export function useEffect(callback: () => (() => void) | void): void {
-   let destroyCallback = callback();
-   if (destroyCallback) getCurrentInstance().subscribeOnDestroy(destroyCallback);
-}
-
-export function useCleanup(cleanupCallback: () => void): () => void {
-   let unsubscribe = getCurrentInstance().subscribeOnDestroy(cleanupCallback);
-   return () => {
-      unsubscribe();
-      cleanupCallback();
-   };
-}
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+
+export function useEffect(callback: () => (() => void) | void): void {
+   let destroyCallback = callback();
+   if (destroyCallback) getCurrentInstance().subscribeOnDestroy(destroyCallback);
+}
+
+export function useCleanup(cleanupCallback: () => void): () => void {
+   let unsubscribe = getCurrentInstance().subscribeOnDestroy(cleanupCallback);
+   return () => {
+      unsubscribe();
+      cleanupCallback();
+   };
+}

package/src/hooks/useInterval.ts

@@ -1,8 +1,8 @@
-import { useCleanup } from "./useEffect";
-
-export function useInterval(callback: () => void, timeout: number): () => void {
-   let timer = setInterval(callback, timeout);
-   return useCleanup(() => {
-      clearInterval(timer);
-   });
-}
+import { useCleanup } from "./useEffect";
+
+export function useInterval(callback: () => void, timeout: number): () => void {
+   let timer = setInterval(callback, timeout);
+   return useCleanup(() => {
+      clearInterval(timer);
+   });
+}

package/src/hooks/useState.ts

@@ -1,20 +1,20 @@
-import { getCurrentInstance } from "../ui/createFunctionalComponent";
-import { Ref } from "../data/Ref";
-
-let key: number = 0;
-
-export function useState<T = any>(defaultValue?: T): Ref<T> {
-   let instance = getCurrentInstance();
-   let storeKey = "_state" + ++key;
-   instance.setState({
-      [storeKey]: defaultValue,
-   });
-
-   return new Ref<T>({
-      get: (): T => instance.state[storeKey],
-      set: (value: T): boolean => {
-         instance.setState({ [storeKey]: value });
-         return true;
-      },
-   });
-}
+import { getCurrentInstance } from "../ui/createFunctionalComponent";
+import { Ref } from "../data/Ref";
+
+let key: number = 0;
+
+export function useState<T = any>(defaultValue?: T): Ref<T> {
+   let instance = getCurrentInstance();
+   let storeKey = "_state" + ++key;
+   instance.setState({
+      [storeKey]: defaultValue,
+   });
+
+   return new Ref<T>({
+      get: (): T => instance.state[storeKey],
+      set: (value: T): boolean => {
+         instance.setState({ [storeKey]: value });
+         return true;
+      },
+   });
+}