cx 25.5.0 → 25.5.2

package/src/ui/IsolatedScope.js

@@ -1,30 +1,30 @@
-import { PureContainer } from "./PureContainer";
-import { isArray } from "../util/isArray";
-
-export class IsolatedScope extends PureContainer {
-   declareData() {
-      return super.declareData(...arguments, {
-         data: { structured: true },
-      });
-   }
-
-   init() {
-      if (typeof this.bind === "string") this.data = { bind: this.bind };
-      else if (isArray(this.bind)) {
-         this.data = {};
-         this.bind.forEach((x, i) => {
-            this.data[String(i)] = { bind: x };
-         });
-      }
-      super.init();
-   }
-
-   explore(context, instance) {
-      if (instance.shouldUpdate) {
-         super.explore(context, instance);
-      } else if (instance.children) {
-         // mark children to prevent sweeping them away
-         for (let i = 0; i < instance.children.length; i++) instance.instanceCache.addChild(instance.children[i]);
-      }
-   }
-}
+import { PureContainer } from "./PureContainer";
+import { isArray } from "../util/isArray";
+
+export class IsolatedScope extends PureContainer {
+   declareData() {
+      return super.declareData(...arguments, {
+         data: { structured: true },
+      });
+   }
+
+   init() {
+      if (typeof this.bind === "string") this.data = { bind: this.bind };
+      else if (isArray(this.bind)) {
+         this.data = {};
+         this.bind.forEach((x, i) => {
+            this.data[String(i)] = { bind: x };
+         });
+      }
+      super.init();
+   }
+
+   explore(context, instance) {
+      if (instance.shouldUpdate) {
+         super.explore(context, instance);
+      } else if (instance.children) {
+         // mark children to prevent sweeping them away
+         for (let i = 0; i < instance.children.length; i++) instance.instanceCache.addChild(instance.children[i]);
+      }
+   }
+}

package/src/ui/Repeater.js

@@ -17,7 +17,7 @@ export class Repeater extends Container {
                structured: true,
             },
          },
-         ...arguments
+         ...arguments,
       );
    }
 
@@ -54,6 +54,13 @@ export class Repeater extends Container {
       this.dataAdapter.initInstance(context, instance);
    }
 
+   applyParentStore(instance) {
+      super.applyParentStore(instance);
+
+      // force prepareData to execute again and propagate the store change to the records
+      if (instance.cached) delete instance.cached.rawData;
+   }
+
    prepareData(context, instance) {
       let { data } = instance;
       if (data.sortField)

package/src/ui/Rescope.js

@@ -1,35 +1,35 @@
-import { Widget } from "./Widget";
-import { PureContainer } from "./PureContainer";
-import { Binding } from "../data/Binding";
-import { ZoomIntoPropertyView } from "../data/ZoomIntoPropertyView";
-import { StructuredInstanceDataAccessor } from "./StructuredInstanceDataAccessor";
-import { isObject } from "../util/isObject";
-
-export class Rescope extends PureContainer {
-   init() {
-      this.binding = Binding.get(this.bind);
-      if (this.rootAlias) this.rootName = this.rootAlias;
-      super.init();
-   }
-
-   initInstance(context, instance) {
-      instance.store = new ZoomIntoPropertyView({
-         store: instance.parentStore,
-         binding: this.binding,
-         rootName: this.rootName,
-         nestedData: isObject(this.data)
-            ? new StructuredInstanceDataAccessor({ instance, data: this.data, useParentStore: true })
-            : null,
-      });
-      super.initInstance(context, instance);
-   }
-
-   applyParentStore(instance) {
-      instance.store.setStore(instance.parentStore);
-   }
-}
-
-Rescope.prototype.bind = "$page";
-Rescope.prototype.rootName = "$root";
-
-Widget.alias("rescope", Rescope);
+import { Widget } from "./Widget";
+import { PureContainer } from "./PureContainer";
+import { Binding } from "../data/Binding";
+import { ZoomIntoPropertyView } from "../data/ZoomIntoPropertyView";
+import { StructuredInstanceDataAccessor } from "./StructuredInstanceDataAccessor";
+import { isObject } from "../util/isObject";
+
+export class Rescope extends PureContainer {
+   init() {
+      this.binding = Binding.get(this.bind);
+      if (this.rootAlias) this.rootName = this.rootAlias;
+      super.init();
+   }
+
+   initInstance(context, instance) {
+      instance.store = new ZoomIntoPropertyView({
+         store: instance.parentStore,
+         binding: this.binding,
+         rootName: this.rootName,
+         nestedData: isObject(this.data)
+            ? new StructuredInstanceDataAccessor({ instance, data: this.data, useParentStore: true })
+            : null,
+      });
+      super.initInstance(context, instance);
+   }
+
+   applyParentStore(instance) {
+      instance.store.setStore(instance.parentStore);
+   }
+}
+
+Rescope.prototype.bind = "$page";
+Rescope.prototype.rootName = "$root";
+
+Widget.alias("rescope", Rescope);

package/src/ui/Restate.js

@@ -1,167 +1,167 @@
-import { PureContainer } from "./PureContainer";
-import { Store } from "../data/Store";
-import { Cx } from "./Cx";
-import { VDOM } from "./VDOM";
-import { isObject } from "../util/isObject";
-import { isUndefined } from "../util/isUndefined";
-import { Binding } from "../data/Binding";
-import { StructuredSelector } from "../data/StructuredSelector";
-import { getCurrentCulture } from "./Culture";
-
-let persistenceCache = {};
-
-export class Restate extends PureContainer {
-   declareData() {
-      return super.declareData(...arguments, {
-         deferredUntilIdle: undefined,
-         idleTimeout: undefined,
-         cacheKey: undefined,
-      });
-   }
-
-   init() {
-      this.container = PureContainer.create({
-         type: PureContainer,
-         items: this.children || this.items,
-         layout: this.layout,
-         controller: this.controller,
-         outerLayout: this.outerLayout,
-         useParentLayout: !this.detached,
-         ws: this.ws,
-      });
-      this.privateDataSelector = new StructuredSelector({
-         props: this.data || {},
-         values: this.data,
-      });
-      delete this.items;
-      delete this.children;
-      delete this.controller;
-      delete this.outerLayout;
-      delete this.layout;
-      if (this.useParentLayout == null) this.useParentLayout = !this.detached;
-      super.init();
-   }
-
-   initSubStore(context, instance) {
-      let { cacheKey } = instance.data;
-      this.privateDataSelector.init(instance.store);
-      instance.subStore = new RestateStore({
-         store: instance.store,
-         detached: this.detached,
-         privateData: this.data || {},
-         data: cacheKey ? persistenceCache[cacheKey] || {} : {},
-         dataSelector: this.privateDataSelector.create(),
-         onSet: (path, value) => instance.nestedDataSet(path, value, this.data),
-      });
-
-      if (cacheKey) {
-         instance.subscribeOnDestroy(() => {
-            persistenceCache[cacheKey] = instance.subStore.getData();
-         });
-      }
-   }
-
-   applyParentStore(instance) {
-      if (instance.subStore) instance.subStore.setStore(instance.parentStore);
-   }
-
-   explore(context, instance) {
-      if (!instance.subStore) this.initSubStore(context, instance);
-      if (instance.subStore.parentDataCheck()) instance.markShouldUpdate();
-      instance.cultureInfo = this.culture ?? getCurrentCulture();
-      if (instance.cache("cultureInfo", instance.culture)) instance.markShouldUpdate();
-      super.explore(context, instance);
-   }
-
-   exploreItems(context, instance, items) {
-      if (!this.detached) {
-         instance.container = instance.getChild(context, this.container, "container", instance.subStore);
-         instance.container.scheduleExploreIfVisible(context);
-         instance.children = [instance.container];
-      }
-   }
-
-   render(context, instance, key) {
-      if (!this.detached) return instance.container.render(context);
-
-      return (
-         <Cx
-            key={key}
-            widget={this.container}
-            parentInstance={instance}
-            store={instance.subStore}
-            subscribe
-            options={this.options}
-            onError={this.onError}
-            deferredUntilIdle={instance.data.deferredUntilIdle}
-            idleTimeout={instance.data.idleTimeout}
-            immediate={this.immediate}
-            cultureInfo={instance.cultureInfo}
-         />
-      );
-   }
-}
-
-Restate.prototype.detached = false;
-Restate.prototype.waitForIdle = false;
-Restate.prototype.immediate = false;
-Restate.prototype.culture = null;
-
-export const PrivateStore = Restate;
-
-class RestateStore extends Store {
-   constructor(config) {
-      super(config);
-      this.parentDataVersion = -1;
-   }
-
-   getData() {
-      this.silently(() => {
-         this.parentDataCheck();
-      });
-      return super.getData();
-   }
-
-   parentDataCheck() {
-      if (this.parentDataVersion == this.store.meta.version) return false;
-      this.parentDataVersion = this.store.meta.version;
-      this.parentData = this.dataSelector(this.store.getData());
-      return this.batch(() => {
-         for (let key in this.parentData) {
-            super.setItem(key, this.parentData[key]);
-         }
-      });
-   }
-
-   setItem(path, value) {
-      let binding = Binding.get(path);
-      let bindingRoot = binding.parts[0];
-      if (!isObject(this.privateData) || !this.privateData.hasOwnProperty(bindingRoot)) {
-         let changed = isUndefined(value) ? super.deleteItem(path) : super.setItem(path, value);
-         return changed;
-      }
-
-      let newValue = value;
-      if (binding.parts.length > 1) newValue = binding.set(this.getData(), value)[bindingRoot];
-      this.onSet(bindingRoot, newValue);
-      this.batch(() => {
-         super.setItem(bindingRoot, newValue);
-         this.parentDataCheck();
-      });
-      return true;
-   }
-
-   deleteItem(path) {
-      return this.setItem(path, undefined);
-   }
-
-   doNotify() {
-      if (!this.detached) this.store.notify();
-      super.doNotify();
-   }
-
-   // override the default implementation to avoid meta overwrites
-   setStore(store) {
-      this.store = store;
-   }
-}
+import { PureContainer } from "./PureContainer";
+import { Store } from "../data/Store";
+import { Cx } from "./Cx";
+import { VDOM } from "./VDOM";
+import { isObject } from "../util/isObject";
+import { isUndefined } from "../util/isUndefined";
+import { Binding } from "../data/Binding";
+import { StructuredSelector } from "../data/StructuredSelector";
+import { getCurrentCulture } from "./Culture";
+
+let persistenceCache = {};
+
+export class Restate extends PureContainer {
+   declareData() {
+      return super.declareData(...arguments, {
+         deferredUntilIdle: undefined,
+         idleTimeout: undefined,
+         cacheKey: undefined,
+      });
+   }
+
+   init() {
+      this.container = PureContainer.create({
+         type: PureContainer,
+         items: this.children || this.items,
+         layout: this.layout,
+         controller: this.controller,
+         outerLayout: this.outerLayout,
+         useParentLayout: !this.detached,
+         ws: this.ws,
+      });
+      this.privateDataSelector = new StructuredSelector({
+         props: this.data || {},
+         values: this.data,
+      });
+      delete this.items;
+      delete this.children;
+      delete this.controller;
+      delete this.outerLayout;
+      delete this.layout;
+      if (this.useParentLayout == null) this.useParentLayout = !this.detached;
+      super.init();
+   }
+
+   initSubStore(context, instance) {
+      let { cacheKey } = instance.data;
+      this.privateDataSelector.init(instance.store);
+      instance.subStore = new RestateStore({
+         store: instance.store,
+         detached: this.detached,
+         privateData: this.data || {},
+         data: cacheKey ? persistenceCache[cacheKey] || {} : {},
+         dataSelector: this.privateDataSelector.create(),
+         onSet: (path, value) => instance.nestedDataSet(path, value, this.data),
+      });
+
+      if (cacheKey) {
+         instance.subscribeOnDestroy(() => {
+            persistenceCache[cacheKey] = instance.subStore.getData();
+         });
+      }
+   }
+
+   applyParentStore(instance) {
+      if (instance.subStore) instance.subStore.setStore(instance.parentStore);
+   }
+
+   explore(context, instance) {
+      if (!instance.subStore) this.initSubStore(context, instance);
+      if (instance.subStore.parentDataCheck()) instance.markShouldUpdate();
+      instance.cultureInfo = this.culture ?? getCurrentCulture();
+      if (instance.cache("cultureInfo", instance.culture)) instance.markShouldUpdate();
+      super.explore(context, instance);
+   }
+
+   exploreItems(context, instance, items) {
+      if (!this.detached) {
+         instance.container = instance.getChild(context, this.container, "container", instance.subStore);
+         instance.container.scheduleExploreIfVisible(context);
+         instance.children = [instance.container];
+      }
+   }
+
+   render(context, instance, key) {
+      if (!this.detached) return instance.container.render(context);
+
+      return (
+         <Cx
+            key={key}
+            widget={this.container}
+            parentInstance={instance}
+            store={instance.subStore}
+            subscribe
+            options={this.options}
+            onError={this.onError}
+            deferredUntilIdle={instance.data.deferredUntilIdle}
+            idleTimeout={instance.data.idleTimeout}
+            immediate={this.immediate}
+            cultureInfo={instance.cultureInfo}
+         />
+      );
+   }
+}
+
+Restate.prototype.detached = false;
+Restate.prototype.waitForIdle = false;
+Restate.prototype.immediate = false;
+Restate.prototype.culture = null;
+
+export const PrivateStore = Restate;
+
+class RestateStore extends Store {
+   constructor(config) {
+      super(config);
+      this.parentDataVersion = -1;
+   }
+
+   getData() {
+      this.silently(() => {
+         this.parentDataCheck();
+      });
+      return super.getData();
+   }
+
+   parentDataCheck() {
+      if (this.parentDataVersion == this.store.meta.version) return false;
+      this.parentDataVersion = this.store.meta.version;
+      this.parentData = this.dataSelector(this.store.getData());
+      return this.batch(() => {
+         for (let key in this.parentData) {
+            super.setItem(key, this.parentData[key]);
+         }
+      });
+   }
+
+   setItem(path, value) {
+      let binding = Binding.get(path);
+      let bindingRoot = binding.parts[0];
+      if (!isObject(this.privateData) || !this.privateData.hasOwnProperty(bindingRoot)) {
+         let changed = isUndefined(value) ? super.deleteItem(path) : super.setItem(path, value);
+         return changed;
+      }
+
+      let newValue = value;
+      if (binding.parts.length > 1) newValue = binding.set(this.getData(), value)[bindingRoot];
+      this.onSet(bindingRoot, newValue);
+      this.batch(() => {
+         super.setItem(bindingRoot, newValue);
+         this.parentDataCheck();
+      });
+      return true;
+   }
+
+   deleteItem(path) {
+      return this.setItem(path, undefined);
+   }
+
+   doNotify() {
+      if (!this.detached) this.store.notify();
+      super.doNotify();
+   }
+
+   // override the default implementation to avoid meta overwrites
+   setStore(store) {
+      this.store = store;
+   }
+}