cx 26.0.4 → 26.0.6

package/src/ui/adapter/TreeAdapter.ts

@@ -1,185 +1,185 @@
-import { Accessor, getAccessor } from "../../data/getAccessor";
-import { isArray } from "../../util/isArray";
-import { ArrayAdapter, ArrayAdapterConfig, RecordStoreCache } from "./ArrayAdapter";
-import { DataAdapterRecord } from "./DataAdapter";
-import { RenderingContext } from "../RenderingContext";
-import { Instance } from "../Instance";
-import { View } from "../../data/View";
-import { Sorter } from "../Prop";
-
-export interface TreeNode {
-   $level?: number;
-   $expanded?: boolean;
-   $leaf?: boolean;
-   $loading?: boolean;
-   $loaded?: boolean;
-   [key: string]: any;
-}
-
-export interface ExpandedState {
-   current?: Set<string | number>;
-   next: Set<string | number>;
-}
-
-export interface TreeAdapterConfig extends ArrayAdapterConfig {
-   childrenField?: string;
-   expandedField?: string;
-   leafField?: string;
-   loadingField?: string;
-   loadedField?: string;
-   onLoadError?: (response: any) => void;
-   foldersFirst?: boolean;
-   hideRootNodes?: boolean;
-   restoreExpandedNodesOnLoad?: boolean;
-   load?: (context: RenderingContext, instance: Instance, data: TreeNode) => Promise<any[]> | any[];
-}
-
-export class TreeAdapter<T extends TreeNode = TreeNode> extends ArrayAdapter<T> {
-   declare public childrenField: string;
-   declare public expandedField: string;
-   declare public leafField: string;
-   declare public loadingField: string;
-   declare public loadedField: string;
-   declare public onLoadError?: (response: any) => void;
-   declare public foldersFirst: boolean;
-   declare public hideRootNodes: boolean;
-   declare public restoreExpandedNodesOnLoad?: boolean;
-   declare public load?: (context: RenderingContext, instance: Instance, data: T) => Promise<any[]> | any[];
-
-   declare protected childrenAccessor?: Accessor;
-   declare protected expandedState?: ExpandedState;
-
-   constructor(config?: TreeAdapterConfig) {
-      super(config);
-   }
-
-   public init(): void {
-      super.init();
-      this.childrenAccessor = getAccessor({ bind: `${this.recordName}.${this.childrenField}` });
-
-      if (this.restoreExpandedNodesOnLoad) {
-         if (!this.keyField) {
-            throw new Error(
-               "Stateful tree adapter requires keyField property to be specified on either Grid or data adapter.",
-            );
-         }
-
-         this.expandedState = {
-            next: new Set(),
-         };
-      }
-   }
-
-   public mapRecords(
-      context: RenderingContext,
-      instance: Instance & Partial<RecordStoreCache>,
-      data: T[],
-      parentStore: View,
-      recordsAccessor?: Accessor,
-   ): DataAdapterRecord<T>[] {
-      const nodes = super.mapRecords(context, instance, data, parentStore, recordsAccessor);
-      const result: DataAdapterRecord<T>[] = [];
-
-      if (this.restoreExpandedNodesOnLoad) {
-         this.expandedState = {
-            current: this.expandedState!.next,
-            next: new Set(),
-         };
-      }
-
-      this.processList(context, instance, 0, "", nodes, result);
-
-      return result;
-   }
-
-   protected processList(
-      context: RenderingContext,
-      instance: Instance & Partial<RecordStoreCache>,
-      level: number,
-      parentKey: string,
-      nodes: DataAdapterRecord<T>[],
-      result: DataAdapterRecord<T>[],
-   ): void {
-      nodes.forEach((record) => {
-         record.key = parentKey + record.key;
-         this.processNode(context, instance, level, result, record);
-      });
-   }
-
-   protected processNode(
-      context: RenderingContext,
-      instance: Instance & Partial<RecordStoreCache>,
-      level: number,
-      result: DataAdapterRecord<T>[],
-      record: DataAdapterRecord<T>,
-   ): void {
-      const isHiddenRootNode = level === 0 && this.hideRootNodes;
-      if (!isHiddenRootNode) {
-         result.push(record);
-      }
-
-      const { data, store } = record;
-      const dataRecord = data as any;
-      dataRecord.$level = this.hideRootNodes ? level - 1 : level;
-
-      if (!dataRecord[this.leafField]) {
-         if (this.restoreExpandedNodesOnLoad && dataRecord[this.expandedField] == null) {
-            dataRecord[this.expandedField] = this.expandedState!.current!.has(dataRecord[this.keyField!]);
-         }
-
-         if (dataRecord[this.expandedField] || isHiddenRootNode) {
-            if (this.restoreExpandedNodesOnLoad) {
-               this.expandedState!.next.add(dataRecord[this.keyField!]);
-            }
-
-            if (dataRecord[this.childrenField]) {
-               const childNodes = super.mapRecords(
-                  context,
-                  instance,
-                  dataRecord[this.childrenField],
-                  store,
-                  this.childrenAccessor,
-               );
-               this.processList(context, instance, level + 1, record.key + ":", childNodes, result);
-            } else if (this.load && !dataRecord[this.loadedField] && !dataRecord[this.loadingField]) {
-               store.set(`${this.recordName}.${this.loadingField}`, true);
-               const response = this.load(context, instance, data);
-               Promise.resolve(response)
-                  .then((children) => {
-                     store.set(`${this.recordName}.${this.childrenField}`, children);
-                     store.set(`${this.recordName}.${this.loadedField}`, true);
-                     store.set(`${this.recordName}.${this.loadingField}`, false);
-                  })
-                  .catch((response) => {
-                     store.set(`${this.recordName}.${this.loadingField}`, false);
-                     if (this.onLoadError) {
-                        this.onLoadError(response);
-                     }
-                  });
-            }
-         } else {
-            dataRecord[this.expandedField] = false;
-         }
-      }
-   }
-
-   public sort(sorters?: Sorter[]): void {
-      if (this.foldersFirst) {
-         if (!sorters || !isArray(sorters)) {
-            sorters = [];
-         }
-         sorters = [{ field: this.leafField, direction: "ASC" }, ...sorters];
-      }
-      super.sort(sorters);
-   }
-}
-
-TreeAdapter.prototype.childrenField = "$children";
-TreeAdapter.prototype.expandedField = "$expanded";
-TreeAdapter.prototype.leafField = "$leaf";
-TreeAdapter.prototype.loadingField = "$loading";
-TreeAdapter.prototype.loadedField = "$loaded";
-TreeAdapter.prototype.foldersFirst = true;
-TreeAdapter.prototype.isTreeAdapter = true;
-TreeAdapter.prototype.hideRootNodes = false;
-TreeAdapter.prototype.cacheByKeyField = false;
+import { Accessor, getAccessor } from "../../data/getAccessor";
+import { isArray } from "../../util/isArray";
+import { ArrayAdapter, ArrayAdapterConfig, RecordStoreCache } from "./ArrayAdapter";
+import { DataAdapterRecord } from "./DataAdapter";
+import { RenderingContext } from "../RenderingContext";
+import { Instance } from "../Instance";
+import { View } from "../../data/View";
+import { Sorter } from "../Prop";
+
+export interface TreeNode {
+   $level?: number;
+   $expanded?: boolean;
+   $leaf?: boolean;
+   $loading?: boolean;
+   $loaded?: boolean;
+   [key: string]: any;
+}
+
+export interface ExpandedState {
+   current?: Set<string | number>;
+   next: Set<string | number>;
+}
+
+export interface TreeAdapterConfig extends ArrayAdapterConfig {
+   childrenField?: string;
+   expandedField?: string;
+   leafField?: string;
+   loadingField?: string;
+   loadedField?: string;
+   onLoadError?: (response: any) => void;
+   foldersFirst?: boolean;
+   hideRootNodes?: boolean;
+   restoreExpandedNodesOnLoad?: boolean;
+   load?: (context: RenderingContext, instance: Instance, data: TreeNode) => Promise<any[]> | any[];
+}
+
+export class TreeAdapter<T extends TreeNode = TreeNode> extends ArrayAdapter<T> {
+   declare public childrenField: string;
+   declare public expandedField: string;
+   declare public leafField: string;
+   declare public loadingField: string;
+   declare public loadedField: string;
+   declare public onLoadError?: (response: any) => void;
+   declare public foldersFirst: boolean;
+   declare public hideRootNodes: boolean;
+   declare public restoreExpandedNodesOnLoad?: boolean;
+   declare public load?: (context: RenderingContext, instance: Instance, data: T) => Promise<any[]> | any[];
+
+   declare protected childrenAccessor?: Accessor;
+   declare protected expandedState?: ExpandedState;
+
+   constructor(config?: TreeAdapterConfig) {
+      super(config);
+   }
+
+   public init(): void {
+      super.init();
+      this.childrenAccessor = getAccessor({ bind: `${this.recordName}.${this.childrenField}` });
+
+      if (this.restoreExpandedNodesOnLoad) {
+         if (!this.keyField) {
+            throw new Error(
+               "Stateful tree adapter requires keyField property to be specified on either Grid or data adapter.",
+            );
+         }
+
+         this.expandedState = {
+            next: new Set(),
+         };
+      }
+   }
+
+   public mapRecords(
+      context: RenderingContext,
+      instance: Instance & Partial<RecordStoreCache>,
+      data: T[],
+      parentStore: View,
+      recordsAccessor?: Accessor,
+   ): DataAdapterRecord<T>[] {
+      const nodes = super.mapRecords(context, instance, data, parentStore, recordsAccessor);
+      const result: DataAdapterRecord<T>[] = [];
+
+      if (this.restoreExpandedNodesOnLoad) {
+         this.expandedState = {
+            current: this.expandedState!.next,
+            next: new Set(),
+         };
+      }
+
+      this.processList(context, instance, 0, "", nodes, result);
+
+      return result;
+   }
+
+   protected processList(
+      context: RenderingContext,
+      instance: Instance & Partial<RecordStoreCache>,
+      level: number,
+      parentKey: string,
+      nodes: DataAdapterRecord<T>[],
+      result: DataAdapterRecord<T>[],
+   ): void {
+      nodes.forEach((record) => {
+         record.key = parentKey + record.key;
+         this.processNode(context, instance, level, result, record);
+      });
+   }
+
+   protected processNode(
+      context: RenderingContext,
+      instance: Instance & Partial<RecordStoreCache>,
+      level: number,
+      result: DataAdapterRecord<T>[],
+      record: DataAdapterRecord<T>,
+   ): void {
+      const isHiddenRootNode = level === 0 && this.hideRootNodes;
+      if (!isHiddenRootNode) {
+         result.push(record);
+      }
+
+      const { data, store } = record;
+      const dataRecord = data as any;
+      dataRecord.$level = this.hideRootNodes ? level - 1 : level;
+
+      if (!dataRecord[this.leafField]) {
+         if (this.restoreExpandedNodesOnLoad && dataRecord[this.expandedField] == null) {
+            dataRecord[this.expandedField] = this.expandedState!.current!.has(dataRecord[this.keyField!]);
+         }
+
+         if (dataRecord[this.expandedField] || isHiddenRootNode) {
+            if (this.restoreExpandedNodesOnLoad) {
+               this.expandedState!.next.add(dataRecord[this.keyField!]);
+            }
+
+            if (dataRecord[this.childrenField]) {
+               const childNodes = super.mapRecords(
+                  context,
+                  instance,
+                  dataRecord[this.childrenField],
+                  store,
+                  this.childrenAccessor,
+               );
+               this.processList(context, instance, level + 1, record.key + ":", childNodes, result);
+            } else if (this.load && !dataRecord[this.loadedField] && !dataRecord[this.loadingField]) {
+               store.set(`${this.recordName}.${this.loadingField}`, true);
+               const response = this.load(context, instance, data);
+               Promise.resolve(response)
+                  .then((children) => {
+                     store.set(`${this.recordName}.${this.childrenField}`, children);
+                     store.set(`${this.recordName}.${this.loadedField}`, true);
+                     store.set(`${this.recordName}.${this.loadingField}`, false);
+                  })
+                  .catch((response) => {
+                     store.set(`${this.recordName}.${this.loadingField}`, false);
+                     if (this.onLoadError) {
+                        this.onLoadError(response);
+                     }
+                  });
+            }
+         } else {
+            dataRecord[this.expandedField] = false;
+         }
+      }
+   }
+
+   public sort(sorters?: Sorter[]): void {
+      if (this.foldersFirst) {
+         if (!sorters || !isArray(sorters)) {
+            sorters = [];
+         }
+         sorters = [{ field: this.leafField, direction: "ASC" }, ...sorters];
+      }
+      super.sort(sorters);
+   }
+}
+
+TreeAdapter.prototype.childrenField = "$children";
+TreeAdapter.prototype.expandedField = "$expanded";
+TreeAdapter.prototype.leafField = "$leaf";
+TreeAdapter.prototype.loadingField = "$loading";
+TreeAdapter.prototype.loadedField = "$loaded";
+TreeAdapter.prototype.foldersFirst = true;
+TreeAdapter.prototype.isTreeAdapter = true;
+TreeAdapter.prototype.hideRootNodes = false;
+TreeAdapter.prototype.cacheByKeyField = false;

package/src/ui/app/History.ts

@@ -1,133 +1,133 @@
-import { Url } from "./Url";
-import { batchUpdatesAndNotify } from "../batchUpdates";
-import { SubscriberList } from "../../util/SubscriberList";
-import { View } from "../../data/View";
-
-interface Transition {
-   url: string;
-   state: any;
-   title: string | null;
-   replace: boolean;
-   completed?: boolean;
-}
-
-type NavigateConfirmationCallback = (state: any) => boolean | Promise<boolean>;
-
-let last = 0;
-let next = 1;
-let transitions: Record<number, Transition> = {};
-let subscribers: SubscriberList | null = null;
-let reload = false;
-let navigateConfirmationCallback: NavigateConfirmationCallback | null = null;
-let permanentNavigateConfirmation = false;
-
-export class History {
-   static store: View;
-   static urlBinding: string;
-   static hashBinding?: string;
-
-   static connect(store: View, urlBinding: string, hashBinding?: string): void {
-      this.store = store;
-      this.urlBinding = urlBinding;
-      this.hashBinding = hashBinding;
-      this.updateStore();
-      window.onpopstate = () => {
-         this.updateStore();
-      };
-   }
-
-   static pushState(state: any, title: string | null, url: string): boolean {
-      return this.confirmAndNavigate(state, title, url);
-   }
-
-   static replaceState(state: any, title: string | null, url: string): boolean {
-      return this.navigate(state, title, url, true);
-   }
-
-   static reloadOnNextChange(): void {
-      reload = true;
-   }
-
-   static addNavigateConfirmation(callback: NavigateConfirmationCallback, permanent = false): void {
-      navigateConfirmationCallback = callback;
-      permanentNavigateConfirmation = permanent;
-   }
-
-   static confirm(continueCallback: () => boolean, state: any): boolean {
-      if (!navigateConfirmationCallback) return continueCallback();
-
-      let result = navigateConfirmationCallback(state);
-      Promise.resolve(result).then((value) => {
-         if (value) {
-            if (!permanentNavigateConfirmation) navigateConfirmationCallback = null;
-            continueCallback();
-         }
-      });
-
-      return false;
-   }
-
-   static confirmAndNavigate(state: any, title: string | null, url: string, replace?: boolean): boolean {
-      return this.confirm(() => this.navigate(state, title, url, replace), url);
-   }
-
-   static navigate(state: any, title: string | null, url: string, replace = false): boolean {
-      url = Url.resolve(url);
-
-      if (!window.history.pushState || reload) {
-         window.location[replace ? "replace" : "assign"](url);
-         return true;
-      }
-
-      let transition: Transition | undefined;
-      let changed = false;
-      batchUpdatesAndNotify(
-         () => {
-            changed = this.updateStore(url);
-            if (changed)
-               transitions[++last] = transition = {
-                  url,
-                  state,
-                  title,
-                  replace,
-               };
-         },
-         () => {
-            if (transition) transition.completed = true;
-
-            //update history once the page is rendered and the title is set
-            while (transitions[next] && transitions[next].completed) {
-               let tr = transitions[next];
-               delete transitions[next];
-               next++;
-               if (tr.replace) {
-                  window.history.replaceState(tr.state, tr.title ?? "", tr.url);
-                  if (subscribers) subscribers.notify(tr.url, "replaceState");
-               } else {
-                  window.history.pushState(tr.state, tr.title ?? "", tr.url);
-                  if (subscribers) subscribers.notify(tr.url, "pushState");
-               }
-            }
-         },
-      );
-
-      return changed;
-   }
-
-   static updateStore(href?: string): boolean {
-      let url = Url.unresolve(href || document.location.href);
-      let hash: string | null = null;
-      let hashIndex = url.indexOf("#");
-      if (hashIndex !== -1) {
-         hash = url.substring(hashIndex);
-         url = url.substring(0, hashIndex);
-      }
-      if (this.hashBinding) this.store.set(this.hashBinding, hash);
-      return this.store.set(this.urlBinding, url);
-   }
-
-   static subscribe(callback: (url: string, op: string) => void): () => void {
-      if (!subscribers) subscribers = new SubscriberList();
-      return subscribers.subscribe(callback);
-   }
-}
+import { Url } from "./Url";
+import { batchUpdatesAndNotify } from "../batchUpdates";
+import { SubscriberList } from "../../util/SubscriberList";
+import { View } from "../../data/View";
+
+interface Transition {
+   url: string;
+   state: any;
+   title: string | null;
+   replace: boolean;
+   completed?: boolean;
+}
+
+type NavigateConfirmationCallback = (state: any) => boolean | Promise<boolean>;
+
+let last = 0;
+let next = 1;
+let transitions: Record<number, Transition> = {};
+let subscribers: SubscriberList | null = null;
+let reload = false;
+let navigateConfirmationCallback: NavigateConfirmationCallback | null = null;
+let permanentNavigateConfirmation = false;
+
+export class History {
+   static store: View;
+   static urlBinding: string;
+   static hashBinding?: string;
+
+   static connect(store: View, urlBinding: string, hashBinding?: string): void {
+      this.store = store;
+      this.urlBinding = urlBinding;
+      this.hashBinding = hashBinding;
+      this.updateStore();
+      window.onpopstate = () => {
+         this.updateStore();
+      };
+   }
+
+   static pushState(state: any, title: string | null, url: string): boolean {
+      return this.confirmAndNavigate(state, title, url);
+   }
+
+   static replaceState(state: any, title: string | null, url: string): boolean {
+      return this.navigate(state, title, url, true);
+   }
+
+   static reloadOnNextChange(): void {
+      reload = true;
+   }
+
+   static addNavigateConfirmation(callback: NavigateConfirmationCallback, permanent = false): void {
+      navigateConfirmationCallback = callback;
+      permanentNavigateConfirmation = permanent;
+   }
+
+   static confirm(continueCallback: () => boolean, state: any): boolean {
+      if (!navigateConfirmationCallback) return continueCallback();
+
+      let result = navigateConfirmationCallback(state);
+      Promise.resolve(result).then((value) => {
+         if (value) {
+            if (!permanentNavigateConfirmation) navigateConfirmationCallback = null;
+            continueCallback();
+         }
+      });
+
+      return false;
+   }
+
+   static confirmAndNavigate(state: any, title: string | null, url: string, replace?: boolean): boolean {
+      return this.confirm(() => this.navigate(state, title, url, replace), url);
+   }
+
+   static navigate(state: any, title: string | null, url: string, replace = false): boolean {
+      url = Url.resolve(url);
+
+      if (!window.history.pushState || reload) {
+         window.location[replace ? "replace" : "assign"](url);
+         return true;
+      }
+
+      let transition: Transition | undefined;
+      let changed = false;
+      batchUpdatesAndNotify(
+         () => {
+            changed = this.updateStore(url);
+            if (changed)
+               transitions[++last] = transition = {
+                  url,
+                  state,
+                  title,
+                  replace,
+               };
+         },
+         () => {
+            if (transition) transition.completed = true;
+
+            //update history once the page is rendered and the title is set
+            while (transitions[next] && transitions[next].completed) {
+               let tr = transitions[next];
+               delete transitions[next];
+               next++;
+               if (tr.replace) {
+                  window.history.replaceState(tr.state, tr.title ?? "", tr.url);
+                  if (subscribers) subscribers.notify(tr.url, "replaceState");
+               } else {
+                  window.history.pushState(tr.state, tr.title ?? "", tr.url);
+                  if (subscribers) subscribers.notify(tr.url, "pushState");
+               }
+            }
+         },
+      );
+
+      return changed;
+   }
+
+   static updateStore(href?: string): boolean {
+      let url = Url.unresolve(href || document.location.href);
+      let hash: string | null = null;
+      let hashIndex = url.indexOf("#");
+      if (hashIndex !== -1) {
+         hash = url.substring(hashIndex);
+         url = url.substring(0, hashIndex);
+      }
+      if (this.hashBinding) this.store.set(this.hashBinding, hash);
+      return this.store.set(this.urlBinding, url);
+   }
+
+   static subscribe(callback: (url: string, op: string) => void): () => void {
+      if (!subscribers) subscribers = new SubscriberList();
+      return subscribers.subscribe(callback);
+   }
+}