cx 26.1.1 → 26.1.3

package/src/data/Ref.ts

@@ -1,104 +1,104 @@
-import { isFunction } from "../util/isFunction";
-import { Component } from "../util/Component";
-import { Binding } from "./Binding";
-import { View } from "./View";
-import { CanMemoize } from "./Selector";
-
-export interface RefConfig<T> {
-   store?: View;
-   path?: string;
-   get?: () => T;
-   set?: (value: T) => boolean;
-}
-
-export class Ref<T = any> extends Component implements CanMemoize<T> {
-   declare isRef?: boolean;
-
-   constructor(config: RefConfig<T>) {
-      super(config);
-      this.get = this.get.bind(this);
-      if (this.set) this.set = this.set.bind(this);
-   }
-
-   get(): T {
-      throw new Error("Ref's get method is not implemented.");
-   }
-
-   set(value: T): boolean {
-      throw new Error("Ref's set method is not implemented.");
-   }
-
-   delete(): boolean {
-      throw new Error("Ref's delete method is not implemented.");
-   }
-
-   // Component.init() override - no-op for compatibility
-   init(): void;
-   // Initialize ref value if it's currently undefined
-   init(value: T): boolean;
-   init(value?: T): boolean | void {
-      if (value === undefined) return; // Component.init() compatibility
-      if (this.get() === undefined) return this.set(value);
-      return false;
-   }
-
-   toggle(): boolean {
-      return this.set(!this.get() as T);
-   }
-
-   update(cb: (currentValue: T, ...args: any[]) => T, ...args: any[]): boolean {
-      return this.set(cb(this.get(), ...args));
-   }
-
-   as(config: any): Ref {
-      return Ref.create(config, {
-         get: this.get,
-         set: this.set,
-      });
-   }
-
-   ref<ST = any>(path: string): Ref<ST> {
-      let binding = Binding.get(path);
-      return Ref.create({
-         get: () => binding.value(this.get()),
-         set: (value: any) => {
-            let data = this.get();
-            let newData = binding.set(data as Record<string, any>, value);
-            if (data === newData) return false;
-            return this.set(newData as T);
-         },
-      }) as Ref<ST>;
-   }
-
-   //allows the function to be passed as a selector, e.g. to computable or addTrigger
-   memoize(): () => T {
-      return this.get;
-   }
-}
-
-Ref.prototype.isRef = true;
-
-Ref.factory = function (alias: any, config?: any, more?: any): Ref {
-   if (isFunction(alias)) {
-      let cfg = {
-         ...config,
-         ...more,
-      };
-
-      if (cfg.store) Object.assign(cfg, cfg.store.getMethods());
-
-      let result = alias(cfg);
-      if (result instanceof Ref) return result;
-
-      return this.create({
-         ...config,
-         ...more,
-         ...result,
-      });
-   }
-
-   return this.create({
-      ...config,
-      ...more,
-   });
-};
+import { isFunction } from "../util/isFunction";
+import { Component } from "../util/Component";
+import { Binding } from "./Binding";
+import { View } from "./View";
+import { CanMemoize } from "./Selector";
+
+export interface RefConfig<T> {
+   store?: View;
+   path?: string;
+   get?: () => T;
+   set?: (value: T) => boolean;
+}
+
+export class Ref<T = any> extends Component implements CanMemoize<T> {
+   declare isRef?: boolean;
+
+   constructor(config: RefConfig<T>) {
+      super(config);
+      this.get = this.get.bind(this);
+      if (this.set) this.set = this.set.bind(this);
+   }
+
+   get(): T {
+      throw new Error("Ref's get method is not implemented.");
+   }
+
+   set(value: T): boolean {
+      throw new Error("Ref's set method is not implemented.");
+   }
+
+   delete(): boolean {
+      throw new Error("Ref's delete method is not implemented.");
+   }
+
+   // Component.init() override - no-op for compatibility
+   init(): void;
+   // Initialize ref value if it's currently undefined
+   init(value: T): boolean;
+   init(value?: T): boolean | void {
+      if (value === undefined) return; // Component.init() compatibility
+      if (this.get() === undefined) return this.set(value);
+      return false;
+   }
+
+   toggle(): boolean {
+      return this.set(!this.get() as T);
+   }
+
+   update(cb: (currentValue: T, ...args: any[]) => T, ...args: any[]): boolean {
+      return this.set(cb(this.get(), ...args));
+   }
+
+   as(config: any): Ref {
+      return Ref.create(config, {
+         get: this.get,
+         set: this.set,
+      });
+   }
+
+   ref<ST = any>(path: string): Ref<ST> {
+      let binding = Binding.get(path);
+      return Ref.create({
+         get: () => binding.value(this.get()),
+         set: (value: any) => {
+            let data = this.get();
+            let newData = binding.set(data as Record<string, any>, value);
+            if (data === newData) return false;
+            return this.set(newData as T);
+         },
+      }) as Ref<ST>;
+   }
+
+   //allows the function to be passed as a selector, e.g. to computable or addTrigger
+   memoize(): () => T {
+      return this.get;
+   }
+}
+
+Ref.prototype.isRef = true;
+
+Ref.factory = function (alias: any, config?: any, more?: any): Ref {
+   if (isFunction(alias)) {
+      let cfg = {
+         ...config,
+         ...more,
+      };
+
+      if (cfg.store) Object.assign(cfg, cfg.store.getMethods());
+
+      let result = alias(cfg);
+      if (result instanceof Ref) return result;
+
+      return this.create({
+         ...config,
+         ...more,
+         ...result,
+      });
+   }
+
+   return this.create({
+      ...config,
+      ...more,
+   });
+};

package/src/data/Selector.ts

@@ -1,10 +1,10 @@
-export interface Selector<T = any> {
-   (data: any): T;
-   memoize?: (warmupData?: unknown) => Selector<T>;
-}
-
-export interface CanMemoize<T = any> {
-   memoize(warmupData?: unknown): Selector<T>;
-}
-
-export type MemoSelector<T = any> = Selector<T> & CanMemoize<T>;
+export interface Selector<T = any> {
+   (data: any): T;
+   memoize?: (warmupData?: unknown) => Selector<T>;
+}
+
+export interface CanMemoize<T = any> {
+   memoize(warmupData?: unknown): Selector<T>;
+}
+
+export type MemoSelector<T = any> = Selector<T> & CanMemoize<T>;

package/src/data/Store.spec.ts

@@ -1,22 +1,22 @@
-import assert from 'assert';
-import { Store } from './Store';
-
-describe('Store', () => {
-
-   const getStore = () => {
-      return new Store({
-         data: {
-            a: 3,
-            item: {
-               firstName: 'Jack'
-            }
-         }
-      });
-   };
-
-   it('changes version on each update', ()=> {
-      let store = getStore();
-      store.set('a', 4);
-      assert.equal(store.getMeta().version, 1);
-   });
-});
+import assert from 'assert';
+import { Store } from './Store';
+
+describe('Store', () => {
+
+   const getStore = () => {
+      return new Store({
+         data: {
+            a: 3,
+            item: {
+               firstName: 'Jack'
+            }
+         }
+      });
+   };
+
+   it('changes version on each update', ()=> {
+      let store = getStore();
+      store.set('a', 4);
+      assert.equal(store.getMeta().version, 1);
+   });
+});

package/src/data/Store.ts

@@ -1,52 +1,52 @@
-import { Binding } from "./Binding";
-import { SubscribableView, SubscribableViewConfig } from "./SubscribableView";
-
-export interface StoreConfig<D = any> extends Omit<SubscribableViewConfig, "store"> {
-   data?: D;
-}
-
-export class Store<D extends Record<string, any> = any> extends SubscribableView<D> {
-   data: D;
-
-   constructor(config: StoreConfig<D> = {}) {
-      super(config);
-      this.data = config.data ?? ({} as D);
-      this.meta = {
-         version: 0,
-      };
-   }
-
-   getData(): D {
-      return this.data;
-   }
-
-   setItem(path: string, value: any): boolean {
-      let next = Binding.get(path).set(this.data, value);
-      if (next != this.data) {
-         this.data = next;
-         this.meta.version++;
-         this.notify(path);
-         return true;
-      }
-      return false;
-   }
-
-   deleteItem(path: string): boolean {
-      let next = Binding.get(path).delete(this.data);
-      if (next != this.data) {
-         this.data = next;
-         this.meta.version++;
-         this.notify(path);
-         return true;
-      }
-      return false;
-   }
-
-   clear(): void {
-      this.data = {} as D;
-      this.meta.version++;
-      this.notify();
-   }
-}
-
-Store.prototype.async = false;
+import { Binding } from "./Binding";
+import { SubscribableView, SubscribableViewConfig } from "./SubscribableView";
+
+export interface StoreConfig<D = any> extends Omit<SubscribableViewConfig, "store"> {
+   data?: D;
+}
+
+export class Store<D extends Record<string, any> = any> extends SubscribableView<D> {
+   data: D;
+
+   constructor(config: StoreConfig<D> = {}) {
+      super(config);
+      this.data = config.data ?? ({} as D);
+      this.meta = {
+         version: 0,
+      };
+   }
+
+   getData(): D {
+      return this.data;
+   }
+
+   setItem(path: string, value: any): boolean {
+      let next = Binding.get(path).set(this.data, value);
+      if (next != this.data) {
+         this.data = next;
+         this.meta.version++;
+         this.notify(path);
+         return true;
+      }
+      return false;
+   }
+
+   deleteItem(path: string): boolean {
+      let next = Binding.get(path).delete(this.data);
+      if (next != this.data) {
+         this.data = next;
+         this.meta.version++;
+         this.notify(path);
+         return true;
+      }
+      return false;
+   }
+
+   clear(): void {
+      this.data = {} as D;
+      this.meta.version++;
+      this.notify();
+   }
+}
+
+Store.prototype.async = false;

package/src/data/StoreProxy.ts

@@ -1,19 +1,19 @@
-import { View } from "./View";
-
-export class StoreProxy extends View {
-   declare store: View;
-
-   constructor(getStore: () => View) {
-      super({
-         store: getStore(),
-      });
-
-      Object.defineProperty(this, "store", {
-         get: getStore,
-      });
-   }
-
-   getData(): any {
-      return this.store.getData();
-   }
-}
+import { View } from "./View";
+
+export class StoreProxy extends View {
+   declare store: View;
+
+   constructor(getStore: () => View) {
+      super({
+         store: getStore(),
+      });
+
+      Object.defineProperty(this, "store", {
+         get: getStore,
+      });
+   }
+
+   getData(): any {
+      return this.store.getData();
+   }
+}

package/src/data/StoreRef.spec.ts

@@ -1,24 +1,24 @@
-import assert from "assert";
-import { Store } from "./Store";
-import { StoreRef } from "./StoreRef";
-
-const getStore = () => {
-   return new Store({
-      data: {
-         person: {
-            name: "Jack",
-         },
-      },
-   });
-};
-
-describe("StoreRef", () => {
-   it("can access child refs", () => {
-      let store = getStore();
-      let person = store.ref("person");
-      let name = person.ref("name");
-      assert.equal(name.get(), "Jack");
-      name.set("John");
-      assert.equal(name.get(), "John");
-   });
-});
+import assert from "assert";
+import { Store } from "./Store";
+import { StoreRef } from "./StoreRef";
+
+const getStore = () => {
+   return new Store({
+      data: {
+         person: {
+            name: "Jack",
+         },
+      },
+   });
+};
+
+describe("StoreRef", () => {
+   it("can access child refs", () => {
+      let store = getStore();
+      let person = store.ref("person");
+      let name = person.ref("name");
+      assert.equal(name.get(), "Jack");
+      name.set("John");
+      assert.equal(name.get(), "John");
+   });
+});

package/src/data/StoreRef.ts

@@ -1,66 +1,66 @@
-import { isAccessorChain } from "./createAccessorModelProxy";
-import { Ref, RefConfig } from "./Ref";
-import { View } from "./View";
-
-interface StoreRefConfig<T> extends RefConfig<T> {
-   store: View;
-   path: string;
-}
-
-export class StoreRef<T = any> extends Ref<T> {
-   declare store: View;
-   declare path: string;
-
-   constructor(config: StoreRefConfig<T>) {
-      super(config);
-      if (isAccessorChain(this.path)) this.path = this.path.toString();
-   }
-
-   get() {
-      return this.store.get(this.path);
-   }
-
-   set(value: T): boolean {
-      return this.store.set(this.path, value);
-   }
-
-   init(): void;
-   init(value: T): boolean;
-   init(value?: T): boolean | void {
-      if (value === undefined) return;
-      return this.store.init(this.path, value);
-   }
-
-   toggle() {
-      return this.store.toggle(this.path);
-   }
-
-   delete() {
-      return this.store.delete(this.path);
-   }
-
-   update(cb: (currentValue: T, ...args: any[]) => T, ...args: any[]): boolean {
-      return this.store.update(this.path, cb, ...args);
-   }
-
-   //allows the function to be passed as a selector, e.g. to computable or addTrigger
-   memoize() {
-      return this.get;
-   }
-
-   ref<ST = any>(path: string): StoreRef<ST> {
-      return new StoreRef<ST>({
-         path: `${this.path}.${path}`,
-         store: this.store,
-      });
-   }
-
-   as(config: RefConfig<T>) {
-      return StoreRef.create(config, {
-         path: this.path,
-         store: this.store,
-         get: this.get,
-         set: this.set,
-      });
-   }
-}
+import { isAccessorChain } from "./createAccessorModelProxy";
+import { Ref, RefConfig } from "./Ref";
+import { View } from "./View";
+
+interface StoreRefConfig<T> extends RefConfig<T> {
+   store: View;
+   path: string;
+}
+
+export class StoreRef<T = any> extends Ref<T> {
+   declare store: View;
+   declare path: string;
+
+   constructor(config: StoreRefConfig<T>) {
+      super(config);
+      if (isAccessorChain(this.path)) this.path = this.path.toString();
+   }
+
+   get() {
+      return this.store.get(this.path);
+   }
+
+   set(value: T): boolean {
+      return this.store.set(this.path, value);
+   }
+
+   init(): void;
+   init(value: T): boolean;
+   init(value?: T): boolean | void {
+      if (value === undefined) return;
+      return this.store.init(this.path, value);
+   }
+
+   toggle() {
+      return this.store.toggle(this.path);
+   }
+
+   delete() {
+      return this.store.delete(this.path);
+   }
+
+   update(cb: (currentValue: T, ...args: any[]) => T, ...args: any[]): boolean {
+      return this.store.update(this.path, cb, ...args);
+   }
+
+   //allows the function to be passed as a selector, e.g. to computable or addTrigger
+   memoize() {
+      return this.get;
+   }
+
+   ref<ST = any>(path: string): StoreRef<ST> {
+      return new StoreRef<ST>({
+         path: `${this.path}.${path}`,
+         store: this.store,
+      });
+   }
+
+   as(config: RefConfig<T>) {
+      return StoreRef.create(config, {
+         path: this.path,
+         store: this.store,
+         get: this.get,
+         set: this.set,
+      });
+   }
+}