@datagrok-libraries/utils 4.1.5 → 4.1.6

package/package.json

@@ -8,7 +8,7 @@
     "email": "amuzychyna@datagrok.ai"
   },
   "fullName": "Utils",
-  "version": "4.1.5",
+  "version": "4.1.6",
   "description": "Common utilities",
   "dependencies": {
     "cash-dom": "^8.1.1",

package/src/items-grid.d.ts

@@ -0,0 +1,64 @@
+import * as DG from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+export type ItemType = {
+    [_: string]: any;
+};
+export type ItemsGridOptions = {
+    removeButtonTooltip?: string;
+    addButtonTooltip?: string;
+    allowRemove?: boolean;
+    allowAdd?: boolean;
+    horizontalInputNames?: boolean;
+    newItemFunction?: () => ItemType;
+};
+/** Editor for predefined properties in a grid form. Supports adding, removing and editing of props. */
+export declare class ItemsGrid {
+    private _root;
+    private _items;
+    /** Observable for when the added item is change */
+    onItemChanged: Subject<{
+        item: ItemType;
+        fieldName: string;
+    }>;
+    /** Observable for when the adding item is change */
+    onAddingItemChanged: Subject<{
+        item: ItemType;
+        fieldName: string;
+    }>;
+    /** Observable for when the item is added */
+    onItemAdded: Subject<ItemType>;
+    /** Observable for when the item is removed */
+    onItemRemoved: Subject<ItemType>;
+    properties: DG.Property[];
+    options: ItemsGridOptions;
+    /**
+     * Creates an instance of ItemsGrid which is a grid form for editing properties.
+     * @param {DG.Property[]}properties - properties to be edited
+     * @param {ItemTypep[]}items - items to be edited
+     * @param {ItemsGridOptions}options - options for the grid
+     * Options include:
+     * removeButtonTooltip - tooltip for the remove button - default is 'Remove item'
+     * addButtonTooltip - tooltip for the add button - default is 'Add item'
+     * allowRemove - whether to allow removing items - default is true
+     * allowAdd - whether to allow adding items - default is true
+     * horizontalInputNames - Show the input names next to intput - default is false, names are shown above the grid.
+     * newItemFunction - function that returns new item - default is undefind, in which case an empty object is created.
+     */
+    constructor(properties: DG.Property[], items?: ItemType[], options?: ItemsGridOptions);
+    get root(): HTMLDivElement;
+    get items(): {
+        [key: string]: any;
+    }[];
+    private render;
+    private getItemDiv;
+}
+/** Usage example:
+ * const props = [DG.Property.js('name2', DG.TYPE.STRING),
+      DG.Property.js('name3', DG.TYPE.NUM),
+      DG.Property.fromOptions({name: 'name4', type: DG.TYPE.DATE_TIME, nullable: true})];
+    const itemsGrid = new ItemsGrid(props);
+ * the component has a root property that can be added to the page
+    ui.dialog('dialog').add(itemsGrid.root).show();
+    at any point, filled fields can be accessed via itemsGrid.items
+ */
+//# sourceMappingURL=items-grid.d.ts.map

package/src/items-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items-grid.d.ts","sourceRoot":"","sources":["items-grid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAEtC,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAE7B,MAAM,MAAM,QAAQ,GAAG;IAAC,CAAC,CAAC,EAAC,MAAM,GAAG,GAAG,CAAA;CAAC,CAAC;AACzC,MAAM,MAAM,gBAAgB,GAAG;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,QAAQ,CAAC;CACpC,CAAC;AAEF,uGAAuG;AACvG,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,MAAM,CAAyB;IAEvC,mDAAmD;IAC5C,aAAa,EAAE,OAAO,CAAC;QAAC,IAAI,EAAC,QAAQ,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAC,CAAiB;IAClF,oDAAoD;IAC7C,mBAAmB,EAAE,OAAO,CAAC;QAAC,IAAI,EAAC,QAAQ,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAC,CAAiB;IACxF,4CAA4C;IACrC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAiB;IACtD,8CAA8C;IACvC,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAiB;IAExD,UAAU,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC;IAC1B,OAAO,EAAE,gBAAgB,CAC+E;IACtG;;;;;;;;;;;;OAYG;gBACO,UAAU,EAAE,EAAE,CAAC,QAAQ,EAAE,EAAE,KAAK,GAAE,QAAQ,EAAO,EAAE,OAAO,GAAE,gBAAqB;IAW7F,IAAI,IAAI,IAAI,cAAc,CAEzB;IAED,IAAI,KAAK,IAAI;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,EAAE,CAElC;IAED,OAAO,CAAC,MAAM;IAyBd,OAAO,CAAC,UAAU;CA2CnB;AAED;;;;;;;;GAQG"}

package/src/items-grid.js

@@ -0,0 +1,118 @@
+import * as ui from 'datagrok-api/ui';
+import { Subject } from 'rxjs';
+/** Editor for predefined properties in a grid form. Supports adding, removing and editing of props. */
+export class ItemsGrid {
+    /**
+     * Creates an instance of ItemsGrid which is a grid form for editing properties.
+     * @param {DG.Property[]}properties - properties to be edited
+     * @param {ItemTypep[]}items - items to be edited
+     * @param {ItemsGridOptions}options - options for the grid
+     * Options include:
+     * removeButtonTooltip - tooltip for the remove button - default is 'Remove item'
+     * addButtonTooltip - tooltip for the add button - default is 'Add item'
+     * allowRemove - whether to allow removing items - default is true
+     * allowAdd - whether to allow adding items - default is true
+     * horizontalInputNames - Show the input names next to intput - default is false, names are shown above the grid.
+     * newItemFunction - function that returns new item - default is undefind, in which case an empty object is created.
+     */
+    constructor(properties, items = [], options = {}) {
+        /** Observable for when the added item is change */
+        this.onItemChanged = new Subject();
+        /** Observable for when the adding item is change */
+        this.onAddingItemChanged = new Subject();
+        /** Observable for when the item is added */
+        this.onItemAdded = new Subject();
+        /** Observable for when the item is removed */
+        this.onItemRemoved = new Subject();
+        this.options = { removeButtonTooltip: 'Remove item', addButtonTooltip: 'Add item', allowAdd: true, allowRemove: true };
+        this.properties = properties;
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        this._root = ui.divV([], { style: {
+                display: 'grid', gridTemplateColumns: `repeat(${this.properties.length + 1}, 1fr)`,
+                alignItems: 'center', gap: '12px'
+            } });
+        this._items = items;
+        this.render();
+    }
+    get root() {
+        return this._root;
+    }
+    get items() {
+        return this._items;
+    }
+    render() {
+        ui.empty(this._root);
+        if (!this.options.horizontalInputNames) {
+            for (const prop of this.properties) {
+                const header = ui.divText(prop.name);
+                header.style.fontWeight = 'bold';
+                this._root.appendChild(header);
+            }
+            this._root.appendChild(ui.divText(''));
+        }
+        for (const item of this._items) {
+            const editors = this.getItemDiv(item);
+            if (editors.length !== this.properties.length + 1)
+                editors.push(ui.div());
+            for (const editor of editors)
+                this._root.appendChild(editor);
+        }
+        if (this.options.allowAdd) {
+            const newEditor = this.getItemDiv(undefined, true);
+            for (const editor of newEditor)
+                this._root.appendChild(editor);
+        }
+    }
+    getItemDiv(item = {}, isAdding) {
+        const editors = [];
+        const inputsMap = {};
+        for (const prop of this.properties) {
+            if (item[prop.name] === undefined)
+                item[prop.name] = null; // needed for date editor, it can not handle undefined
+            const input = ui.input.forProperty(prop, item);
+            editors.push(this.options.horizontalInputNames ? input.root : input.input);
+            inputsMap[prop.name] = input;
+            input.onChanged(() => {
+                isAdding ? this.onAddingItemChanged.next({ item, fieldName: prop.name }) :
+                    this.onItemChanged.next({ item, fieldName: prop.name });
+            });
+            input.root.style.alignItems = 'center'; // needed for molecule editor
+        }
+        let companionButton = null;
+        if (isAdding) {
+            const addButton = ui.icons.add(() => {
+                const newItem = this.options.newItemFunction ? this.options.newItemFunction() : {};
+                Object.keys(inputsMap).forEach((pName) => {
+                    newItem[pName] = inputsMap[pName].value;
+                });
+                this.onItemAdded.next(newItem);
+                this._items.push(newItem);
+                this.render();
+            }, this.options.addButtonTooltip);
+            companionButton = addButton;
+        }
+        else {
+            if (!this.options.allowRemove)
+                return editors;
+            const removeButton = ui.icons.delete(() => {
+                this.onItemRemoved.next(item);
+                this._items.splice(this._items.indexOf(item), 1);
+                this.render();
+            }, this.options.removeButtonTooltip);
+            companionButton = removeButton;
+        }
+        editors.push(companionButton);
+        companionButton.style.color = '#2083d5';
+        return editors;
+    }
+}
+/** Usage example:
+ * const props = [DG.Property.js('name2', DG.TYPE.STRING),
+      DG.Property.js('name3', DG.TYPE.NUM),
+      DG.Property.fromOptions({name: 'name4', type: DG.TYPE.DATE_TIME, nullable: true})];
+    const itemsGrid = new ItemsGrid(props);
+ * the component has a root property that can be added to the page
+    ui.dialog('dialog').add(itemsGrid.root).show();
+    at any point, filled fields can be accessed via itemsGrid.items
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"items-grid.js","sourceRoot":"","sources":["items-grid.ts"],"names":[],"mappings":"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","sourcesContent":["import * as DG from 'datagrok-api/dg';\nimport * as ui from 'datagrok-api/ui';\nimport {Subject} from 'rxjs';\n\nexport type ItemType = {[_:string]: any};\nexport type ItemsGridOptions = {\n    removeButtonTooltip?: string,\n    addButtonTooltip?: string,\n    allowRemove?: boolean,\n    allowAdd?: boolean,\n    horizontalInputNames?: boolean,\n    newItemFunction?: () => ItemType,\n};\n\n/** Editor for predefined properties in a grid form. Supports adding, removing and editing of props. */\nexport class ItemsGrid {\n  private _root: HTMLDivElement;\n  private _items: {[key: string]: any}[];\n\n  /** Observable for when the added item is change */\n  public onItemChanged: Subject<{item:ItemType, fieldName: string}> = new Subject();\n  /** Observable for when the adding item is change */\n  public onAddingItemChanged: Subject<{item:ItemType, fieldName: string}> = new Subject();\n  /** Observable for when the item is added */\n  public onItemAdded: Subject<ItemType> = new Subject();\n  /** Observable for when the item is removed */\n  public onItemRemoved: Subject<ItemType> = new Subject();\n\n  properties: DG.Property[];\n  options: ItemsGridOptions =\n    {removeButtonTooltip: 'Remove item', addButtonTooltip: 'Add item', allowAdd: true, allowRemove: true};\n    /**\n     * Creates an instance of ItemsGrid which is a grid form for editing properties.\n     * @param {DG.Property[]}properties - properties to be edited\n     * @param {ItemTypep[]}items - items to be edited\n     * @param {ItemsGridOptions}options - options for the grid\n     * Options include:\n     * removeButtonTooltip - tooltip for the remove button - default is 'Remove item'\n     * addButtonTooltip - tooltip for the add button - default is 'Add item'\n     * allowRemove - whether to allow removing items - default is true\n     * allowAdd - whether to allow adding items - default is true\n     * horizontalInputNames - Show the input names next to intput - default is false, names are shown above the grid.\n     * newItemFunction - function that returns new item - default is undefind, in which case an empty object is created.\n     */\n  constructor(properties: DG.Property[], items: ItemType[] = [], options: ItemsGridOptions = {}) {\n    this.properties = properties;\n    this.options = {...this.options, ...options};\n    this._root = ui.divV([],\n      {style: {\n        display: 'grid', gridTemplateColumns: `repeat(${this.properties.length + 1}, 1fr)`,\n        alignItems: 'center', gap: '12px'}});\n    this._items = items;\n    this.render();\n  }\n\n  get root(): HTMLDivElement {\n    return this._root;\n  }\n\n  get items(): {[key: string]: any}[] {\n    return this._items;\n  }\n\n  private render(): void {\n    ui.empty(this._root);\n    if (!this.options.horizontalInputNames) {\n      for (const prop of this.properties) {\n        const header = ui.divText(prop.name);\n        header.style.fontWeight = 'bold';\n        this._root.appendChild(header);\n      }\n      this._root.appendChild(ui.divText(''));\n    }\n    for (const item of this._items) {\n      const editors = this.getItemDiv(item);\n      if (editors.length !== this.properties.length + 1)\n        editors.push(ui.div());\n      for (const editor of editors)\n        this._root.appendChild(editor);\n    }\n\n    if (this.options.allowAdd) {\n      const newEditor = this.getItemDiv(undefined, true);\n      for (const editor of newEditor)\n        this._root.appendChild(editor);\n    }\n  }\n\n  private getItemDiv(item: ItemType = {}, isAdding?: boolean): HTMLElement[] {\n    const editors: HTMLElement[] = [];\n\n    const inputsMap: {[_: string]: DG.InputBase} = {};\n    for (const prop of this.properties) {\n      if (item[prop.name] === undefined)\n        item[prop.name] = null; // needed for date editor, it can not handle undefined\n      const input = ui.input.forProperty(prop, item);\n      editors.push(this.options.horizontalInputNames ? input.root : input.input);\n      inputsMap[prop.name] = input;\n      input.onChanged(() => {\n        isAdding ? this.onAddingItemChanged.next({item, fieldName: prop.name}) :\n          this.onItemChanged.next({item, fieldName: prop.name});\n      });\n      input.root.style.alignItems = 'center'; // needed for molecule editor\n    }\n\n    let companionButton: HTMLElement | null = null;\n    if (isAdding) {\n      const addButton = ui.icons.add(() => {\n        const newItem: ItemType = this.options.newItemFunction ? this.options.newItemFunction() : {};\n        Object.keys(inputsMap).forEach((pName) => {\n          newItem[pName] = inputsMap[pName].value;\n        });\n        this.onItemAdded.next(newItem);\n        this._items.push(newItem);\n        this.render();\n      }, this.options.addButtonTooltip);\n      companionButton = addButton;\n    } else {\n      if (!this.options.allowRemove) return editors;\n      const removeButton = ui.icons.delete(() => {\n        this.onItemRemoved.next(item);\n        this._items.splice(this._items.indexOf(item), 1);\n        this.render();\n      }, this.options.removeButtonTooltip);\n      companionButton = removeButton;\n    }\n\n    editors.push(companionButton);\n    companionButton.style.color = '#2083d5';\n    return editors;\n  }\n}\n\n/** Usage example:\n * const props = [DG.Property.js('name2', DG.TYPE.STRING),\n      DG.Property.js('name3', DG.TYPE.NUM),\n      DG.Property.fromOptions({name: 'name4', type: DG.TYPE.DATE_TIME, nullable: true})];\n    const itemsGrid = new ItemsGrid(props);\n * the component has a root property that can be added to the page\n    ui.dialog('dialog').add(itemsGrid.root).show();\n    at any point, filled fields can be accessed via itemsGrid.items\n */\n"]}