cx 26.1.0 → 26.1.1

package/src/data/ExposedValueView.ts

@@ -1,89 +1,89 @@
-import { View, ViewConfig } from "./View";
-import { Binding } from "./Binding";
-
-export interface ExposedValueViewConfig extends ViewConfig {
-   containerBinding: Binding;
-   key?: string | null;
-   recordName?: string;
-}
-
-export class ExposedValueView extends View {
-   declare key: string;
-   declare containerBinding: Binding;
-   declare recordName: string;
-   declare immutable?: boolean;
-   declare store: View;
-
-   constructor(config: ExposedValueViewConfig) {
-      super(config);
-   }
-
-   getData(): any {
-      if (
-         this.sealed &&
-         this.meta.version === this.cache.version &&
-         this.cache.key === this.key &&
-         this.meta == this.store.meta
-      )
-         return this.cache.result;
-
-      let data = this.store.getData();
-      let container = this.containerBinding.value(data) || {};
-      let record = container[this.key];
-
-      this.cache.version = this.meta.version;
-      this.cache.key = this.key;
-      this.cache.result = this.sealed || this.immutable || this.store.sealed ? { ...data } : data;
-      this.cache.result[this.recordName] = record;
-      this.meta = this.store.meta;
-      return this.cache.result;
-   }
-
-   setKey(key: string) {
-      this.key = key;
-   }
-
-   getKey() {
-      return this.key;
-   }
-
-   setItem(path: string, value: any) {
-      if (path == this.recordName || path.indexOf(this.recordName + ".") == 0) {
-         var data = this.getData();
-         var d = Binding.get(path).set(data, value);
-         if (d === data) return false;
-         var container = this.containerBinding.value(d);
-         var record = d[this.recordName];
-         var newContainer = Object.assign({}, container);
-         newContainer[this.key] = record;
-         return this.store.setItem(this.containerBinding.path, newContainer);
-      }
-      return this.store.setItem(path, value);
-   }
-
-   deleteItem(path: string) {
-      var data, container, newContainer;
-
-      if (path == this.recordName) {
-         data = this.getData();
-         container = this.containerBinding.value(data);
-         if (!container || !container.hasOwnProperty(path)) return false;
-         newContainer = Object.assign({}, container);
-         delete newContainer[this.key];
-         this.store.set(this.containerBinding.path, newContainer);
-      } else if (path.indexOf(this.recordName + ".") == 0) {
-         data = this.getData();
-         var d = Binding.get(path).delete(data);
-         if (d === data) return false;
-         container = this.containerBinding.value(d);
-         var record = d[this.recordName];
-         newContainer = Object.assign({}, container);
-         newContainer[this.key] = record;
-         return this.store.setItem(this.containerBinding.path, newContainer);
-      }
-
-      return this.store.deleteItem(path);
-   }
-}
-
-ExposedValueView.prototype.immutable = false;
+import { View, ViewConfig } from "./View";
+import { Binding } from "./Binding";
+
+export interface ExposedValueViewConfig extends ViewConfig {
+   containerBinding: Binding;
+   key?: string | null;
+   recordName?: string;
+}
+
+export class ExposedValueView extends View {
+   declare key: string;
+   declare containerBinding: Binding;
+   declare recordName: string;
+   declare immutable?: boolean;
+   declare store: View;
+
+   constructor(config: ExposedValueViewConfig) {
+      super(config);
+   }
+
+   getData(): any {
+      if (
+         this.sealed &&
+         this.meta.version === this.cache.version &&
+         this.cache.key === this.key &&
+         this.meta == this.store.meta
+      )
+         return this.cache.result;
+
+      let data = this.store.getData();
+      let container = this.containerBinding.value(data) || {};
+      let record = container[this.key];
+
+      this.cache.version = this.meta.version;
+      this.cache.key = this.key;
+      this.cache.result = this.sealed || this.immutable || this.store.sealed ? { ...data } : data;
+      this.cache.result[this.recordName] = record;
+      this.meta = this.store.meta;
+      return this.cache.result;
+   }
+
+   setKey(key: string) {
+      this.key = key;
+   }
+
+   getKey() {
+      return this.key;
+   }
+
+   setItem(path: string, value: any) {
+      if (path == this.recordName || path.indexOf(this.recordName + ".") == 0) {
+         var data = this.getData();
+         var d = Binding.get(path).set(data, value);
+         if (d === data) return false;
+         var container = this.containerBinding.value(d);
+         var record = d[this.recordName];
+         var newContainer = Object.assign({}, container);
+         newContainer[this.key] = record;
+         return this.store.setItem(this.containerBinding.path, newContainer);
+      }
+      return this.store.setItem(path, value);
+   }
+
+   deleteItem(path: string) {
+      var data, container, newContainer;
+
+      if (path == this.recordName) {
+         data = this.getData();
+         container = this.containerBinding.value(data);
+         if (!container || !container.hasOwnProperty(path)) return false;
+         newContainer = Object.assign({}, container);
+         delete newContainer[this.key];
+         this.store.set(this.containerBinding.path, newContainer);
+      } else if (path.indexOf(this.recordName + ".") == 0) {
+         data = this.getData();
+         var d = Binding.get(path).delete(data);
+         if (d === data) return false;
+         container = this.containerBinding.value(d);
+         var record = d[this.recordName];
+         newContainer = Object.assign({}, container);
+         newContainer[this.key] = record;
+         return this.store.setItem(this.containerBinding.path, newContainer);
+      }
+
+      return this.store.deleteItem(path);
+   }
+}
+
+ExposedValueView.prototype.immutable = false;

package/src/data/Grouper.spec.ts

@@ -1,57 +1,57 @@
-import { Grouper } from "./Grouper";
-import assert from "assert";
-
-describe("Grouper", function () {
-   describe("single grouping", function () {
-      it("should work", function () {
-         let data = [
-            { name: "John", age: 12 },
-            { name: "Jane", age: 12 },
-         ];
-
-         let grouper = new Grouper({ name: { bind: "name" } });
-         grouper.processAll(data);
-
-         let results = grouper.getResults();
-         // console.log(results);
-         assert.equal(results.length, 2);
-      });
-
-      it("keys can have nested properties", function () {
-         let data = [
-            { name: "John", age: 12 },
-            { name: "Jane", age: 12 },
-         ];
-
-         let grouper = new Grouper({ "person.name": { bind: "name" } });
-         grouper.processAll(data);
-
-         let results = grouper.getResults();
-         assert.equal(results.length, 2);
-         assert.equal(results[0].key.person?.name, "John");
-         assert.equal(results[1].key.person?.name, "Jane");
-      });
-   });
-
-   describe("multi grouping", function () {
-      it("should work", function () {
-         let data = [
-            { name: "John", age: 12 },
-            { name: "John", age: 12 },
-            { name: "John", age: 13 },
-            { name: "John", age: 14 },
-            { name: "Jane", age: 12 },
-            { name: "Jane", age: 13 },
-            { name: "Jane", age: 14 },
-         ];
-
-         let grouper = new Grouper({ name: { bind: "name" }, age: { bind: "age" } });
-         grouper.processAll(data);
-
-         let results = grouper.getResults();
-         // console.log(results);
-         assert.equal(results.length, 6);
-         assert.equal(results[0].records.length, 2);
-      });
-   });
-});
+import { Grouper } from "./Grouper";
+import assert from "assert";
+
+describe("Grouper", function () {
+   describe("single grouping", function () {
+      it("should work", function () {
+         let data = [
+            { name: "John", age: 12 },
+            { name: "Jane", age: 12 },
+         ];
+
+         let grouper = new Grouper({ name: { bind: "name" } });
+         grouper.processAll(data);
+
+         let results = grouper.getResults();
+         // console.log(results);
+         assert.equal(results.length, 2);
+      });
+
+      it("keys can have nested properties", function () {
+         let data = [
+            { name: "John", age: 12 },
+            { name: "Jane", age: 12 },
+         ];
+
+         let grouper = new Grouper({ "person.name": { bind: "name" } });
+         grouper.processAll(data);
+
+         let results = grouper.getResults();
+         assert.equal(results.length, 2);
+         assert.equal(results[0].key.person?.name, "John");
+         assert.equal(results[1].key.person?.name, "Jane");
+      });
+   });
+
+   describe("multi grouping", function () {
+      it("should work", function () {
+         let data = [
+            { name: "John", age: 12 },
+            { name: "John", age: 12 },
+            { name: "John", age: 13 },
+            { name: "John", age: 14 },
+            { name: "Jane", age: 12 },
+            { name: "Jane", age: 13 },
+            { name: "Jane", age: 14 },
+         ];
+
+         let grouper = new Grouper({ name: { bind: "name" }, age: { bind: "age" } });
+         grouper.processAll(data);
+
+         let results = grouper.getResults();
+         // console.log(results);
+         assert.equal(results.length, 6);
+         assert.equal(results[0].records.length, 2);
+      });
+   });
+});

package/src/data/NestedDataView.ts

@@ -1,43 +1,43 @@
-import { View, ViewConfig } from "./View";
-import { AugmentedViewBase } from "../data/AugmentedViewBase";
-
-export interface StructuredDataAccessor {
-   getSelector(): (data: object) => Record<string, any>;
-   get(): object;
-   setItem(key: string, value: any): boolean;
-   containsKey(key: string): boolean;
-   getKeys(): string[];
-}
-
-export interface NestedDataViewConfig extends ViewConfig {
-   nestedData?: StructuredDataAccessor;
-   store: View;
-}
-
-export class NestedDataView extends AugmentedViewBase {
-   declare nestedData?: StructuredDataAccessor;
-
-   constructor(config: NestedDataViewConfig) {
-      super(config);
-   }
-
-   protected embedAugmentData(result: Record<string, any>, parentStoreData: Record<string, any>): void {
-      if (this.nestedData) {
-         let nested = this.nestedData.getSelector()(parentStoreData);
-         for (let key in nested) result[key] = nested[key];
-      }
-   }
-
-   protected isExtraKey(key: string): boolean {
-      return !!this.nestedData && this.nestedData.containsKey(key);
-   }
-
-   protected setExtraKeyValue(key: string, value: any): boolean {
-      if (!this.nestedData) throw new Error("Internal error. This should not happen.");
-      return this.nestedData.setItem(key, value);
-   }
-
-   protected deleteExtraKeyValue(key: string): boolean {
-      return this.setExtraKeyValue(key, undefined);
-   }
-}
+import { View, ViewConfig } from "./View";
+import { AugmentedViewBase } from "../data/AugmentedViewBase";
+
+export interface StructuredDataAccessor {
+   getSelector(): (data: object) => Record<string, any>;
+   get(): object;
+   setItem(key: string, value: any): boolean;
+   containsKey(key: string): boolean;
+   getKeys(): string[];
+}
+
+export interface NestedDataViewConfig extends ViewConfig {
+   nestedData?: StructuredDataAccessor;
+   store: View;
+}
+
+export class NestedDataView extends AugmentedViewBase {
+   declare nestedData?: StructuredDataAccessor;
+
+   constructor(config: NestedDataViewConfig) {
+      super(config);
+   }
+
+   protected embedAugmentData(result: Record<string, any>, parentStoreData: Record<string, any>): void {
+      if (this.nestedData) {
+         let nested = this.nestedData.getSelector()(parentStoreData);
+         for (let key in nested) result[key] = nested[key];
+      }
+   }
+
+   protected isExtraKey(key: string): boolean {
+      return !!this.nestedData && this.nestedData.containsKey(key);
+   }
+
+   protected setExtraKeyValue(key: string, value: any): boolean {
+      if (!this.nestedData) throw new Error("Internal error. This should not happen.");
+      return this.nestedData.setItem(key, value);
+   }
+
+   protected deleteExtraKeyValue(key: string): boolean {
+      return this.setExtraKeyValue(key, undefined);
+   }
+}

package/src/data/ReadOnlyDataView.ts

@@ -1,39 +1,39 @@
-import { View, ViewConfig } from "./View";
-
-export interface ReadOnlyDataViewConfig extends ViewConfig {
-   data?: any;
-}
-
-export class ReadOnlyDataView extends View {
-   declare store: View;
-   declare data?: any;
-   declare immutable?: boolean;
-
-   constructor(config?: ReadOnlyDataViewConfig) {
-      super(config);
-   }
-
-   getData(): any {
-      if (this.sealed && this.meta.version === this.cache.version && this.cache.data === this.data)
-         return this.cache.result;
-
-      let data = this.store.getData();
-      this.cache.result =
-         this.sealed || this.immutable || this.store.sealed
-            ? Object.assign({}, data, this.getAdditionalData(data))
-            : Object.assign(data, this.getAdditionalData(data));
-      this.cache.version = this.meta.version;
-      this.cache.data = this.data;
-      return this.cache.result;
-   }
-
-   getAdditionalData(data?: any): any {
-      return this.data;
-   }
-
-   setData(data: any): void {
-      this.data = data;
-   }
-}
-
-ReadOnlyDataView.prototype.immutable = false;
+import { View, ViewConfig } from "./View";
+
+export interface ReadOnlyDataViewConfig extends ViewConfig {
+   data?: any;
+}
+
+export class ReadOnlyDataView extends View {
+   declare store: View;
+   declare data?: any;
+   declare immutable?: boolean;
+
+   constructor(config?: ReadOnlyDataViewConfig) {
+      super(config);
+   }
+
+   getData(): any {
+      if (this.sealed && this.meta.version === this.cache.version && this.cache.data === this.data)
+         return this.cache.result;
+
+      let data = this.store.getData();
+      this.cache.result =
+         this.sealed || this.immutable || this.store.sealed
+            ? Object.assign({}, data, this.getAdditionalData(data))
+            : Object.assign(data, this.getAdditionalData(data));
+      this.cache.version = this.meta.version;
+      this.cache.data = this.data;
+      return this.cache.result;
+   }
+
+   getAdditionalData(data?: any): any {
+      return this.data;
+   }
+
+   setData(data: any): void {
+      this.data = data;
+   }
+}
+
+ReadOnlyDataView.prototype.immutable = false;

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