cx 24.9.1 → 24.9.2

package/src/ui/Instance.d.ts

@@ -1,72 +1,72 @@
-import { Record } from "../core";
-import { RenderingContext } from "./RenderingContext";
-import { View } from "../data/View";
-import { Widget } from "./Widget";
-
-export class Instance<ViewModel = any, Controller = any> {
-   store: View<ViewModel>;
-   data: Record;
-   widget: Widget;
-   key: number;
-   id: string;
-   controller: Controller;
-   parentOptions: any;
-   children?: Instance[];
-
-   constructor(widget: Widget, key: string | number, parent?: Instance, store?: View);
-
-   setStore(store: View): void;
-
-   init(context: RenderingContext): void;
-
-   explore(context: RenderingContext): boolean;
-
-   prepare(context: RenderingContext): void;
-
-   cleanup(context: RenderingContext): void;
-
-   render(context: RenderingContext, keyPrefix?: string): JSX.Element | void;
-
-   setState(state: Cx.Record): void;
-
-   set(prop: string, value: any, internal?: boolean);
-
-   definePropertySetter(prop: string, setter: (value: any) => void): boolean;
-
-   /**
-    * @protected
-    * @param prop
-    * @param value
-    * @returns {boolean}
-    */
-   protected doSet(prop: string, value: any): boolean;
-
-   replaceState(state: Cx.Config);
-
-   getInstanceCache(): InstanceCache;
-
-   clearChildrenCache();
-
-   getChild(context: RenderingContext | null, widget: Widget, keyPrefix?: string, store?: View): Instance;
-
-   getDetachedChild(widget: Widget, key: number | string, store?: View): Instance;
-
-   // TODO: check return type
-   prepareRenderCleanupChild(widget: Widget, store?: View, keyPrefix?: string, options?: object): JSX.Element | void;
-
-   getJsxEventProps(): Cx.Config;
-
-   nestedDataSet(key: string, value: any, dataConfig: Cx.Config): boolean;
-
-   invokeControllerMethod(methodName: string, ...args: any[]);
-}
-
-export class InstanceCache {
-   constructor(parent: Instance);
-
-   getChild(widget: Widget, store: View, keyPrefix?: string): Instance;
-
-   mark();
-
-   sweep();
-}
+import { Record } from "../core";
+import { RenderingContext } from "./RenderingContext";
+import { View } from "../data/View";
+import { Widget } from "./Widget";
+
+export class Instance<ViewModel = any, Controller = any> {
+   store: View<ViewModel>;
+   data: Record;
+   widget: Widget;
+   key: number;
+   id: string;
+   controller: Controller;
+   parentOptions: any;
+   children?: Instance[];
+
+   constructor(widget: Widget, key: string | number, parent?: Instance, store?: View);
+
+   setStore(store: View): void;
+
+   init(context: RenderingContext): void;
+
+   explore(context: RenderingContext): boolean;
+
+   prepare(context: RenderingContext): void;
+
+   cleanup(context: RenderingContext): void;
+
+   render(context: RenderingContext, keyPrefix?: string): JSX.Element | void;
+
+   setState(state: Cx.Record): void;
+
+   set(prop: string, value: any, internal?: boolean);
+
+   definePropertySetter(prop: string, setter: (value: any) => void): boolean;
+
+   /**
+    * @protected
+    * @param prop
+    * @param value
+    * @returns {boolean}
+    */
+   protected doSet(prop: string, value: any): boolean;
+
+   replaceState(state: Cx.Config);
+
+   getInstanceCache(): InstanceCache;
+
+   clearChildrenCache();
+
+   getChild(context: RenderingContext | null, widget: Widget, keyPrefix?: string, store?: View): Instance;
+
+   getDetachedChild(widget: Widget, key: number | string, store?: View): Instance;
+
+   // TODO: check return type
+   prepareRenderCleanupChild(widget: Widget, store?: View, keyPrefix?: string, options?: object): JSX.Element | void;
+
+   getJsxEventProps(): Cx.Config;
+
+   nestedDataSet(key: string, value: any, dataConfig: Cx.Config): boolean;
+
+   invokeControllerMethod(methodName: string, ...args: any[]);
+}
+
+export class InstanceCache {
+   constructor(parent: Instance);
+
+   getChild(widget: Widget, store: View, keyPrefix?: string): Instance;
+
+   mark();
+
+   sweep();
+}

package/src/ui/VDOM.d.ts

@@ -1,12 +1,12 @@
-import { HtmlElement, react } from "cx/widgets";
-import { ReactElement } from "react";
-export interface VDOM {
-   createElement(type, props, ...children);
-   allowRenderOutputCaching?: boolean;
-
-   DOM: {
-      render(reactElement: ReactElement, container: HtmlElement): void;
-      unmountComponentAtNode(container: HtmlElement): void;
-      createRoot?(container: HtmlElement): any;
-   };
-}
+import { HtmlElement, react } from "cx/widgets";
+import { ReactElement } from "react";
+export interface VDOM {
+   createElement(type, props, ...children);
+   allowRenderOutputCaching?: boolean;
+
+   DOM: {
+      render(reactElement: ReactElement, container: HtmlElement): void;
+      unmountComponentAtNode(container: HtmlElement): void;
+      createRoot?(container: HtmlElement): any;
+   };
+}

package/src/ui/app/startAppLoop.js

@@ -1,58 +1,58 @@
-import { Widget, VDOM } from "../Widget";
-import { Store } from "../../data/Store";
-import { Cx } from "../Cx";
-
-export function startAppLoop(parentDOMElement, storeOrInstance, widget, options = {}) {
-   if (!parentDOMElement || parentDOMElement.nodeType !== 1)
-      throw new Error("First argument to startAppLoop should be a valid DOM element.");
-
-   let store, instance, parentInstance;
-
-   if (!storeOrInstance) storeOrInstance = new Store();
-
-   if (storeOrInstance.notify) store = storeOrInstance;
-   else if (storeOrInstance.getChild) {
-      if (storeOrInstance.widget === widget) instance = storeOrInstance;
-      else parentInstance = storeOrInstance;
-   } else throw new Error("Second argument to startAppLoop should be either of type Store or Instance");
-
-   let content = (
-      <Cx
-         store={store}
-         widget={widget}
-         instance={instance}
-         parentInstance={parentInstance}
-         options={options}
-         subscribe
-      />
-   );
-
-   let root = null;
-   if (VDOM.DOM.createRoot) {
-      root = VDOM.DOM.createRoot(parentDOMElement);
-      root.render(content);
-   } else VDOM.DOM.render(content, parentDOMElement);
-
-   let stopped = false;
-
-   return function () {
-      if (stopped) return;
-
-      stopped = true;
-
-      if (!options.destroyDelay) destroy(parentDOMElement, options, root);
-      else {
-         setTimeout(() => {
-            destroy(parentDOMElement, options, root);
-         }, options.destroyDelay);
-      }
-   };
-}
-
-function destroy(parentDOMElement, options, root) {
-   if (root) root.unmount();
-   else VDOM.DOM.unmountComponentAtNode(parentDOMElement);
-
-   if (options.removeParentDOMElement && parentDOMElement.parentNode)
-      parentDOMElement.parentNode.removeChild(parentDOMElement);
-}
+import { Widget, VDOM } from "../Widget";
+import { Store } from "../../data/Store";
+import { Cx } from "../Cx";
+
+export function startAppLoop(parentDOMElement, storeOrInstance, widget, options = {}) {
+   if (!parentDOMElement || parentDOMElement.nodeType !== 1)
+      throw new Error("First argument to startAppLoop should be a valid DOM element.");
+
+   let store, instance, parentInstance;
+
+   if (!storeOrInstance) storeOrInstance = new Store();
+
+   if (storeOrInstance.notify) store = storeOrInstance;
+   else if (storeOrInstance.getChild) {
+      if (storeOrInstance.widget === widget) instance = storeOrInstance;
+      else parentInstance = storeOrInstance;
+   } else throw new Error("Second argument to startAppLoop should be either of type Store or Instance");
+
+   let content = (
+      <Cx
+         store={store}
+         widget={widget}
+         instance={instance}
+         parentInstance={parentInstance}
+         options={options}
+         subscribe
+      />
+   );
+
+   let root = null;
+   if (VDOM.DOM.createRoot) {
+      root = VDOM.DOM.createRoot(parentDOMElement);
+      root.render(content);
+   } else VDOM.DOM.render(content, parentDOMElement);
+
+   let stopped = false;
+
+   return function () {
+      if (stopped) return;
+
+      stopped = true;
+
+      if (!options.destroyDelay) destroy(parentDOMElement, options, root);
+      else {
+         setTimeout(() => {
+            destroy(parentDOMElement, options, root);
+         }, options.destroyDelay);
+      }
+   };
+}
+
+function destroy(parentDOMElement, options, root) {
+   if (root) root.unmount();
+   else VDOM.DOM.unmountComponentAtNode(parentDOMElement);
+
+   if (options.removeParentDOMElement && parentDOMElement.parentNode)
+      parentDOMElement.parentNode.removeChild(parentDOMElement);
+}

package/src/ui/index.d.ts

@@ -1,42 +1,42 @@
-export * from "./Controller";
-export * from "./Widget";
-export * from "./Container";
-export * from "./PureContainer";
-export * from "./Repeater";
-export * from "./Rescope";
-export * from "./StaticText";
-export * from "./Text";
-export * from "./CSS";
-export * from "./CSSHelper";
-export * from "./FocusManager";
-export * from "./ResizeManager";
-export * from "./ZIndexManager";
-export * from "./Format";
-export * from "./Culture";
-export * from "./Localization";
-export * from "./Cx";
-export * from "./Instance";
-export * from "./RenderingContext";
-export * from "./ContentResolver";
-export * from "./batchUpdates";
-export * from "./IsolatedScope";
-export * from "./DetachedScope";
-export * from "./Restate";
-export * from "./DataProxy";
-export * from "./keyboardShortcuts";
-export * from "./createFunctionalComponent";
-export * from "./StructuredInstanceDataAccessor";
-export * from "./HoverSync";
-
-export * from "./selection/index";
-export * from "./layout/index";
-export * from "./app/index";
-export * from "./adapter/index";
-
-export * from "./bind";
-export * from "./tpl";
-export * from "./expr";
-
-//re-export computable here
-import { computable } from "../data/computable";
-export { computable };
+export * from "./Controller";
+export * from "./Widget";
+export * from "./Container";
+export * from "./PureContainer";
+export * from "./Repeater";
+export * from "./Rescope";
+export * from "./StaticText";
+export * from "./Text";
+export * from "./CSS";
+export * from "./CSSHelper";
+export * from "./FocusManager";
+export * from "./ResizeManager";
+export * from "./ZIndexManager";
+export * from "./Format";
+export * from "./Culture";
+export * from "./Localization";
+export * from "./Cx";
+export * from "./Instance";
+export * from "./RenderingContext";
+export * from "./ContentResolver";
+export * from "./batchUpdates";
+export * from "./IsolatedScope";
+export * from "./DetachedScope";
+export * from "./Restate";
+export * from "./DataProxy";
+export * from "./keyboardShortcuts";
+export * from "./createFunctionalComponent";
+export * from "./StructuredInstanceDataAccessor";
+export * from "./HoverSync";
+
+export * from "./selection/index";
+export * from "./layout/index";
+export * from "./app/index";
+export * from "./adapter/index";
+
+export * from "./bind";
+export * from "./tpl";
+export * from "./expr";
+
+//re-export computable here
+import { computable } from "../data/computable";
+export { computable };

package/src/ui/layout/LabelsTopLayout.js

@@ -1,135 +1,135 @@
-import {VDOM, getContent, contentAppend} from '../Widget';
-import {Container} from '../Container';
-import {PureContainer} from '../PureContainer';
-import {isArray} from '../../util/isArray';
-import {isUndefined} from '../../util/isUndefined';
-import {isNumber} from "../../util/isNumber";
-
-function validContent(r) {
-   let content = [];
-   for (let key in r)
-      if (key != "label")
-         contentAppend(content, r[key]);
-   return content;
-}
-
-export class LabelsTopLayout extends Container {
-
-   init() {
-      if (this.vertical && isUndefined(this.columns))
-         this.columns = 1;
-
-      super.init();
-   }
-
-   render(context, instance, key) {
-      let {children, data} = instance;
-
-      let state = {
-         rows: [],
-         currentRow: 0,
-         labelCells: [],
-         fieldCells: [],
-         rowCapacities: [this.columns]
-      };
-
-      const processContent = (r) => {
-         if (!r)
-            return;
-         if (isArray(r.content) && r.useParentLayout)
-            r.content.forEach((x) => processContent(x));
-         else if (r.atomic && r.type == "layout-cell")
-            this.addItem(state, isArray(r.content) && r.content.length == 1 ? r.content[0] : r.content, r.data);
-         else
-            this.addItem(state, r, {});
-      };
-
-      children.forEach(item => processContent(item.vdom));
-
-      this.addRow(state);
-
-      return <table key={key} className={data.classNames} style={data.style}>
-         <tbody>
-         {state.rows}
-         </tbody>
-      </table>;
-   }
-
-   addRow(state) {
-      if (state.labelCells.length > 0)
-         state.rows.push(<tr key={state.rows.length}>{state.labelCells}</tr>);
-
-      if (state.fieldCells.length > 0)
-         state.rows.push(<tr key={state.rows.length}>{state.fieldCells}</tr>);
-
-      state.labelCells = [];
-      state.fieldCells = [];
-      state.currentRow++;
-      if (state.currentRow == state.rowCapacities.length)
-         state.rowCapacities.push(this.columns);
-   }
-
-
-   addItem(state, item, data) {
-
-      while (state.labelCells.length == state.rowCapacities[state.currentRow])
-         this.addRow(state);
-
-      if (data.rowSpan > 1) {
-         for (let row = state.currentRow + 1; row < state.currentRow + data.rowSpan; row++) {
-            if (row == state.rowCapacities.length)
-               state.rowCapacities.push(this.columns);
-            state.rowCapacities[row] -= data.colSpan || 1;
-         }
-      }
-
-      if (data.colSpan > 1)
-         state.rowCapacities[state.currentRow] -= data.colSpan - 1;
-
-      state.labelCells.push(
-         <td className={this.CSS.element(this.baseClass, "label")} key={state.labelCells.length} colSpan={data.colSpan}>
-            {getContent(item.label)}
-         </td>
-      );
-      state.fieldCells.push(
-         <td className={this.CSS.element(this.baseClass, "field")}
-             key={state.fieldCells.length}
-             colSpan={data.colSpan}
-             rowSpan={isNumber(data.rowSpan) ? 2 * data.rowSpan - 1 : undefined}
-             style={data.style}
-         >
-            {validContent(item)}
-         </td>
-      );
-   }
-}
-
-LabelsTopLayout.prototype.baseClass = 'labelstoplayout';
-LabelsTopLayout.prototype.vertical = false;
-LabelsTopLayout.prototype.columns = undefined;
-LabelsTopLayout.prototype.styled = true;
-
-export class LabelsTopLayoutCell extends PureContainer {
-
-   declareData(...args) {
-      super.declareData(...args, {
-         colSpan: undefined,
-         rowSpan: undefined
-      })
-   }
-
-   render(context, instance, key) {
-
-      let { content } = this.renderChildren(context, instance);
-
-      return {
-         atomic: true,
-         type: 'layout-cell',
-         data: instance.data,
-         content
-      }
-   }
-}
-
-LabelsTopLayoutCell.prototype.styled = true;
+import {VDOM, getContent, contentAppend} from '../Widget';
+import {Container} from '../Container';
+import {PureContainer} from '../PureContainer';
+import {isArray} from '../../util/isArray';
+import {isUndefined} from '../../util/isUndefined';
+import {isNumber} from "../../util/isNumber";
+
+function validContent(r) {
+   let content = [];
+   for (let key in r)
+      if (key != "label")
+         contentAppend(content, r[key]);
+   return content;
+}
+
+export class LabelsTopLayout extends Container {
+
+   init() {
+      if (this.vertical && isUndefined(this.columns))
+         this.columns = 1;
+
+      super.init();
+   }
+
+   render(context, instance, key) {
+      let {children, data} = instance;
+
+      let state = {
+         rows: [],
+         currentRow: 0,
+         labelCells: [],
+         fieldCells: [],
+         rowCapacities: [this.columns]
+      };
+
+      const processContent = (r) => {
+         if (!r)
+            return;
+         if (isArray(r.content) && r.useParentLayout)
+            r.content.forEach((x) => processContent(x));
+         else if (r.atomic && r.type == "layout-cell")
+            this.addItem(state, isArray(r.content) && r.content.length == 1 ? r.content[0] : r.content, r.data);
+         else
+            this.addItem(state, r, {});
+      };
+
+      children.forEach(item => processContent(item.vdom));
+
+      this.addRow(state);
+
+      return <table key={key} className={data.classNames} style={data.style}>
+         <tbody>
+         {state.rows}
+         </tbody>
+      </table>;
+   }
+
+   addRow(state) {
+      if (state.labelCells.length > 0)
+         state.rows.push(<tr key={state.rows.length}>{state.labelCells}</tr>);
+
+      if (state.fieldCells.length > 0)
+         state.rows.push(<tr key={state.rows.length}>{state.fieldCells}</tr>);
+
+      state.labelCells = [];
+      state.fieldCells = [];
+      state.currentRow++;
+      if (state.currentRow == state.rowCapacities.length)
+         state.rowCapacities.push(this.columns);
+   }
+
+
+   addItem(state, item, data) {
+
+      while (state.labelCells.length == state.rowCapacities[state.currentRow])
+         this.addRow(state);
+
+      if (data.rowSpan > 1) {
+         for (let row = state.currentRow + 1; row < state.currentRow + data.rowSpan; row++) {
+            if (row == state.rowCapacities.length)
+               state.rowCapacities.push(this.columns);
+            state.rowCapacities[row] -= data.colSpan || 1;
+         }
+      }
+
+      if (data.colSpan > 1)
+         state.rowCapacities[state.currentRow] -= data.colSpan - 1;
+
+      state.labelCells.push(
+         <td className={this.CSS.element(this.baseClass, "label")} key={state.labelCells.length} colSpan={data.colSpan}>
+            {getContent(item.label)}
+         </td>
+      );
+      state.fieldCells.push(
+         <td className={this.CSS.element(this.baseClass, "field")}
+             key={state.fieldCells.length}
+             colSpan={data.colSpan}
+             rowSpan={isNumber(data.rowSpan) ? 2 * data.rowSpan - 1 : undefined}
+             style={data.style}
+         >
+            {validContent(item)}
+         </td>
+      );
+   }
+}
+
+LabelsTopLayout.prototype.baseClass = 'labelstoplayout';
+LabelsTopLayout.prototype.vertical = false;
+LabelsTopLayout.prototype.columns = undefined;
+LabelsTopLayout.prototype.styled = true;
+
+export class LabelsTopLayoutCell extends PureContainer {
+
+   declareData(...args) {
+      super.declareData(...args, {
+         colSpan: undefined,
+         rowSpan: undefined
+      })
+   }
+
+   render(context, instance, key) {
+
+      let { content } = this.renderChildren(context, instance);
+
+      return {
+         atomic: true,
+         type: 'layout-cell',
+         data: instance.data,
+         content
+      }
+   }
+}
+
+LabelsTopLayoutCell.prototype.styled = true;
 LabelsTopLayoutCell.prototype.useParentLayout = true;

package/src/util/Console.d.ts

@@ -1,4 +1,4 @@
-export class Console {
-   static log(...args: unknown[]): void;
-   static warn(...args: unknown[]): void;
-}
+export class Console {
+   static log(...args: unknown[]): void;
+   static warn(...args: unknown[]): void;
+}