@neovici/cosmoz-omnitable 14.14.3 → 14.15.0

package/dist/cosmoz-omnitable-item-row.js

@@ -0,0 +1,19 @@
+import { component, html } from '@pionjs/pion';
+import { repeat } from 'lit-html/directives/repeat.js';
+const renderCell = (column, data, onItemChange) => column.editable
+    ? column.renderEditCell(column, data, onItemChange(column, data.item))
+    : column.renderCell(column, data);
+const ItemRow = ({ columns, groupOnColumn, item, index, selected, expanded, onItemChange, }) => repeat(columns, (column) => column.name, (column) => {
+    return html `<div
+				class="cell itemRow-cell ${column.cellClass ?? ''}"
+				part="cell itemRow-cell cell-${column.name} itemRow-cell-${column.name}"
+				?hidden="${column === groupOnColumn}"
+				?editable="${column.editable}"
+				title="${column.cellTitleFn(column, item)}"
+				name="${column.name}"
+			>
+				${renderCell(column, { item, index, selected, expanded }, onItemChange)}
+			</div>`;
+});
+customElements.define('cosmoz-omnitable-item-row', component(ItemRow, { useShadowDOM: false }));
+//# sourceMappingURL=cosmoz-omnitable-item-row.js.map

package/dist/cosmoz-omnitable-skeleton.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cosmoz-omnitable-skeleton.d.ts.map

package/dist/cosmoz-omnitable-skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-omnitable-skeleton.d.ts","sourceRoot":"","sources":["../src/cosmoz-omnitable-skeleton.js"],"names":[],"mappings":""}

package/{cosmoz-omnitable-skeleton.js → dist/cosmoz-omnitable-skeleton.js}

@@ -1,6 +1,5 @@
 import { html, css, component } from '@pionjs/pion';
-
-const styles = css`
+const styles = css `
 	:host {
 		max-width: 100%;
 		overflow-x: hidden;
@@ -43,33 +42,18 @@ const styles = css`
 		}
 	}
 `;
-
 const Skeleton = ({ settingsConfig }) => {
-	const { columns, collapsed } = settingsConfig,
-		showingColumns = columns.filter(
-			(column) => !collapsed.some((hidden) => hidden.name === column.name),
-		);
-
-	return html`<div class="skeleton">
-		${Array.from(
-			{ length: 5 },
-			() =>
-				html`<div>
+    const { columns, collapsed } = settingsConfig, showingColumns = columns.filter((column) => !collapsed.some((hidden) => hidden.name === column.name));
+    return html `<div class="skeleton">
+		${Array.from({ length: 5 }, () => html `<div>
 					<div class="checkbox"></div>
-					${showingColumns.map(
-						(col) =>
-							html`<div
+					${showingColumns.map((col) => html `<div
 								class="cell"
 								part=${`cell-${col.name}`}
 								name=${col.name}
-							></div>`,
-					)}
-				</div>`,
-		)}
+							></div>`)}
+				</div>`)}
 	</div>`;
 };
-
-customElements.define(
-	'cosmoz-omnitable-skeleton',
-	component(Skeleton, { styleSheets: [styles] }),
-);
+customElements.define('cosmoz-omnitable-skeleton', component(Skeleton, { styleSheets: [styles] }));
+//# sourceMappingURL=cosmoz-omnitable-skeleton.js.map

package/dist/cosmoz-omnitable-styles.d.ts

@@ -0,0 +1,4 @@
+export const checkbox: string;
+declare const _default: string;
+export default _default;
+//# sourceMappingURL=cosmoz-omnitable-styles.d.ts.map

package/dist/cosmoz-omnitable-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-omnitable-styles.d.ts","sourceRoot":"","sources":["../src/cosmoz-omnitable-styles.js"],"names":[],"mappings":"AAGA,8BA8EE"}

package/{cosmoz-omnitable-styles.js → dist/cosmoz-omnitable-styles.js}

@@ -1,7 +1,6 @@
 /* eslint-disable max-lines */
 import { tagged as css } from '@neovici/cosmoz-utils';
-
-export const checkbox = css`
+export const checkbox = css `
 	.checkbox {
 		box-sizing: border-box;
 		width: 18px;
@@ -80,8 +79,7 @@ export const checkbox = css`
 		);
 	}
 `;
-
-export default css`
+export default css `
 	:host {
 		display: flex;
 		flex-direction: column;
@@ -584,3 +582,4 @@ export default css`
 		display:none;
 	}
 `;
+//# sourceMappingURL=cosmoz-omnitable-styles.js.map

package/dist/cosmoz-omnitable.d.ts

@@ -0,0 +1,3 @@
+export const actionSlots: import("lit-html").TemplateResult<1>;
+export const actionSlotsPolymer: HTMLTemplateElement;
+//# sourceMappingURL=cosmoz-omnitable.d.ts.map

package/dist/cosmoz-omnitable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-omnitable.d.ts","sourceRoot":"","sources":["../src/cosmoz-omnitable.js"],"names":[],"mappings":"AAgFa,+DAA4D;AACxE,qDAA0E"}

package/{cosmoz-omnitable.js → dist/cosmoz-omnitable.js}

@@ -1,34 +1,27 @@
 import '@neovici/cosmoz-bottom-bar';
 import '@polymer/iron-icon/iron-icon';
 import '@polymer/iron-icons/iron-icons';
-
 import './cosmoz-omnitable-column';
 import './cosmoz-omnitable-columns';
 import './cosmoz-omnitable-group-row';
 import './cosmoz-omnitable-header-row';
 import './cosmoz-omnitable-item-expand';
 import './cosmoz-omnitable-item-row';
-
 import { notifyProperty } from '@neovici/cosmoz-utils/hooks/use-notify-property';
 import { component } from '@pionjs/pion';
 import { html as polymerHtml } from '@polymer/polymer/lib/utils/html-tag';
 import { html } from 'lit-html';
 import { guard } from 'lit-html/directives/guard.js';
-
 import styles from './cosmoz-omnitable-styles';
 import { renderFooter } from './lib/render-footer';
 import { renderHeader } from './lib/render-header';
 import { renderList } from './lib/render-list';
 import { useOmnitable } from './lib/use-omnitable';
-
 import './grouped-list/index.js';
-
 const shimCSS = (s) => window.ShadyCSS?.ApplyShim?.transformCssText?.(s) || s;
-
 const Omnitable = (host) => {
-	const { header, list, footer } = useOmnitable(host);
-
-	return html`
+    const { header, list, footer } = useOmnitable(host);
+    return html `
 		<style>
 			${guard([], () => shimCSS(styles))}
 		</style>
@@ -46,37 +39,31 @@ const Omnitable = (host) => {
 		</div>
 	`;
 };
-
-customElements.define(
-	'cosmoz-omnitable',
-	class extends component(Omnitable, {
-		observedAttributes: [
-			'hash-param',
-			'sort-on',
-			'group-on',
-			'descending',
-			'group-on-descending',
-			'hide-select-all',
-			'settings-id',
-			'no-local',
-			'no-local-sort',
-			'no-local-filter',
-			'loading',
-			'mini-breakpoint',
-		],
-	}) {
-		connectedCallback() {
-			super.connectedCallback();
-			notifyProperty(this, 'selectedItems', []);
-			notifyProperty(this, 'visibleData', []);
-			notifyProperty(this, 'sortedFilteredGroupedItems', []);
-		}
-	},
-);
-
+customElements.define('cosmoz-omnitable', class extends component(Omnitable, {
+    observedAttributes: [
+        'hash-param',
+        'sort-on',
+        'group-on',
+        'descending',
+        'group-on-descending',
+        'hide-select-all',
+        'settings-id',
+        'no-local',
+        'no-local-sort',
+        'no-local-filter',
+        'loading',
+        'mini-breakpoint',
+    ],
+}) {
+    connectedCallback() {
+        super.connectedCallback();
+        notifyProperty(this, 'selectedItems', []);
+        notifyProperty(this, 'visibleData', []);
+        notifyProperty(this, 'sortedFilteredGroupedItems', []);
+    }
+});
 const tmplt = `
 	<slot name="actions" slot="actions"></slot>
 `;
-
-export const actionSlots = html(Object.assign([tmplt], { raw: [tmplt] })),
-	actionSlotsPolymer = polymerHtml(Object.assign([tmplt], { raw: [tmplt] }));
+export const actionSlots = html(Object.assign([tmplt], { raw: [tmplt] })), actionSlotsPolymer = polymerHtml(Object.assign([tmplt], { raw: [tmplt] }));
+//# sourceMappingURL=cosmoz-omnitable.js.map

package/dist/grouped-list/cosmoz-grouped-list-row.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cosmoz-grouped-list-row.d.ts.map

package/dist/grouped-list/cosmoz-grouped-list-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-grouped-list-row.d.ts","sourceRoot":"","sources":["../../src/grouped-list/cosmoz-grouped-list-row.js"],"names":[],"mappings":""}

package/dist/grouped-list/cosmoz-grouped-list-row.js

@@ -0,0 +1,31 @@
+import { render } from 'lit-html';
+customElements.define('cosmoz-grouped-list-row', class Element extends HTMLElement {
+    get item() {
+        return this._item;
+    }
+    set item(item) {
+        this._item = item;
+        this._render();
+    }
+    get index() {
+        return this._index;
+    }
+    set index(index) {
+        this._index = index;
+        this._render();
+    }
+    get renderFn() {
+        return this._renderFn;
+    }
+    set renderFn(renderFn) {
+        this._renderFn = renderFn;
+        this._render();
+    }
+    _render() {
+        if (this._item == null || this._index == null || this._renderFn == null) {
+            return;
+        }
+        render(this._renderFn(this._item, this._index), this);
+    }
+});
+//# sourceMappingURL=cosmoz-grouped-list-row.js.map

package/dist/grouped-list/cosmoz-grouped-list.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cosmoz-grouped-list.d.ts.map

package/dist/grouped-list/cosmoz-grouped-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-grouped-list.d.ts","sourceRoot":"","sources":["../../src/grouped-list/cosmoz-grouped-list.js"],"names":[],"mappings":""}

package/dist/grouped-list/cosmoz-grouped-list.js

@@ -0,0 +1,5 @@
+import { renderCosmozGroupedList, useCosmozGroupedList, } from './use-cosmoz-grouped-list.js';
+import { component } from '@pionjs/pion';
+const CosmozGroupedList = (host) => renderCosmozGroupedList(useCosmozGroupedList(host));
+customElements.define('cosmoz-grouped-list', component(CosmozGroupedList, { useShadowDOM: false }));
+//# sourceMappingURL=cosmoz-grouped-list.js.map

package/dist/grouped-list/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/grouped-list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grouped-list/index.js"],"names":[],"mappings":""}

package/{grouped-list → dist/grouped-list}/index.js

@@ -1 +1,2 @@
 import './cosmoz-grouped-list.js';
+//# sourceMappingURL=index.js.map

package/dist/grouped-list/use-collapsible-items.d.ts

@@ -0,0 +1,7 @@
+export function useCollapsibleItems(): {
+    state: WeakMap<object, any>;
+    signal: WeakMap<object, any>[];
+    toggleFold: (item: any, folded: any) => void;
+    toggleCollapse: (item: any, collapsed: any) => void;
+};
+//# sourceMappingURL=use-collapsible-items.d.ts.map

package/dist/grouped-list/use-collapsible-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-collapsible-items.d.ts","sourceRoot":"","sources":["../../src/grouped-list/use-collapsible-items.js"],"names":[],"mappings":"AAIO;;;;;EA2BN"}

package/dist/grouped-list/use-collapsible-items.js

@@ -0,0 +1,27 @@
+import { useCallback } from '@pionjs/pion';
+import { useWeakState } from './use-weak-state';
+import { isGroup } from './utils';
+export const useCollapsibleItems = () => {
+    const { setItemState, state, signal } = useWeakState(), toggleFold = useCallback((item, folded) => {
+        if (!isGroup(item)) {
+            return;
+        }
+        setItemState(item, (state) => ({
+            folded: folded !== undefined ? folded : !state.folded,
+        }));
+    }, []), toggleCollapse = useCallback((item, collapsed) => {
+        if (isGroup(item)) {
+            return;
+        }
+        setItemState(item, (state) => ({
+            expanded: collapsed !== undefined ? !collapsed : !state.expanded,
+        }));
+    }, []);
+    return {
+        state,
+        signal,
+        toggleFold,
+        toggleCollapse,
+    };
+};
+//# sourceMappingURL=use-collapsible-items.js.map

package/dist/grouped-list/use-cosmoz-grouped-list.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {Object} params
+ * @param {Function} params.renderRow
+ * @param {Array} params.flatData
+ * @returns {*}
+ */
+export function renderCosmozGroupedList({ renderRow, flatData }: {
+    renderRow: Function;
+    flatData: any[];
+}): any;
+export function useCosmozGroupedList(host: any): {
+    renderRow: (item: any, index: any) => any;
+    flatData: any;
+};
+//# sourceMappingURL=use-cosmoz-grouped-list.d.ts.map

package/dist/grouped-list/use-cosmoz-grouped-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-cosmoz-grouped-list.d.ts","sourceRoot":"","sources":["../../src/grouped-list/use-cosmoz-grouped-list.js"],"names":[],"mappings":"AA2FA;;;;;GAKG;AACH,iEAJG;IAAyB,SAAS;IACZ,QAAQ;CAC9B,GAAU,GAAC,CAYb;AAjGD;;;EA+EE"}

package/dist/grouped-list/use-cosmoz-grouped-list.js

@@ -0,0 +1,66 @@
+import { useImperativeApi } from '@neovici/cosmoz-utils/hooks/use-imperative-api';
+import { useNotifyProperty } from '@neovici/cosmoz-utils/hooks/use-notify-property';
+import { useCallback, useLayoutEffect, useMemo } from '@pionjs/pion';
+import { html } from 'lit-html';
+import './cosmoz-grouped-list-row';
+import { useCollapsibleItems } from './use-collapsible-items';
+import { useSelectedItems } from './use-selected-items';
+import { byReference, isExpanded, isFolded, prepareData } from './utils';
+import { virtualize } from '@lit-labs/virtualizer/virtualize.js';
+const styles = {
+    host: { position: 'relative', display: 'flex', flexDirection: 'column' },
+}, useCosmozGroupedList = (host) => {
+    const { data, renderItem, renderGroup, displayEmptyGroups, compareItemsFn = byReference, } = host, { toggleFold, toggleCollapse, state, signal } = useCollapsibleItems(), 
+    // TODO: state changes trigger recalculation, which is slow (200ms with 10k items)
+    // it only makes sense to do it when a group is folded
+    // suggested fix: separate signal for item collapse and group fold
+    flatData = useMemo(() => prepareData(data, displayEmptyGroups, state), [data, displayEmptyGroups, signal]), { selectedItems, isItemSelected, isGroupSelected, isSelected, select, deselect, selectOnly, selectAll, deselectAll, toggleSelect, toggleSelectTo, } = useSelectedItems({ initial: [], compareItemsFn, data, flatData }), renderRow = useCallback((item, index) => Array.isArray(item.items)
+        ? renderGroup(item, index, {
+            selected: isGroupSelected(item, selectedItems),
+            folded: isFolded(item, state),
+            toggleSelect: (selected) => toggleSelect(item, typeof selected === 'boolean' ? selected : undefined),
+            toggleFold: () => toggleFold(item),
+        })
+        : renderItem(item, index, {
+            selected: selectedItems.includes(item),
+            expanded: isExpanded(item, state),
+            toggleSelect: (selected) => toggleSelect(item, typeof selected === 'boolean' ? selected : undefined),
+            toggleCollapse: () => toggleCollapse(item),
+        }), [renderItem, renderGroup, selectedItems, toggleSelect, signal]);
+    useLayoutEffect(() => Object.assign(host.style, styles.host), []);
+    useNotifyProperty('selectedItems', selectedItems);
+    const api = {
+        toggleFold,
+        toggleCollapse,
+        isItemSelected,
+        isGroupSelected,
+        isSelected,
+        select,
+        deselect,
+        selectOnly,
+        selectAll,
+        deselectAll,
+        toggleSelect,
+        toggleSelectTo,
+    };
+    useImperativeApi(api, Object.values(api));
+    return { renderRow, flatData };
+};
+/**
+ * @param {Object} params
+ * @param {Function} params.renderRow
+ * @param {Array} params.flatData
+ * @returns {*}
+ */
+const renderCosmozGroupedList = ({ renderRow, flatData }) => {
+    return virtualize({
+        items: flatData,
+        renderItem: (item, index) => html `<cosmoz-grouped-list-row
+				.item=${item}
+				.index=${index}
+				.renderFn=${renderRow}
+			></cosmoz-grouped-list-row>`,
+    });
+};
+export { renderCosmozGroupedList, useCosmozGroupedList };
+//# sourceMappingURL=use-cosmoz-grouped-list.js.map

package/dist/grouped-list/use-selected-items.d.ts

@@ -0,0 +1,19 @@
+export function useSelectedItems({ initial, compareItemsFn, data, flatData, }: {
+    initial: any;
+    compareItemsFn: any;
+    data: any;
+    flatData: any;
+}): {
+    selectedItems: any;
+    isItemSelected: (item: any) => any;
+    isGroupSelected: (group: any) => any;
+    isSelected: (item: any) => any;
+    select: (item: any) => void;
+    deselect: (item: any) => void;
+    selectOnly: (item: any) => void;
+    selectAll: () => void;
+    deselectAll: () => void;
+    toggleSelect: (item: any, selected?: boolean) => void;
+    toggleSelectTo: (item: any, selected: any) => void;
+};
+//# sourceMappingURL=use-selected-items.d.ts.map

package/dist/grouped-list/use-selected-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-selected-items.d.ts","sourceRoot":"","sources":["../../src/grouped-list/use-selected-items.js"],"names":[],"mappings":"AAGO;;;;;;;;;;;;;;;;;EAwIN"}

package/dist/grouped-list/use-selected-items.js

@@ -0,0 +1,105 @@
+import { useCallback, useEffect, useState } from '@pionjs/pion';
+import { isGroup } from './utils';
+export const useSelectedItems = ({ initial, compareItemsFn, data, flatData, }) => {
+    const [selectedItems, setSelectedItems] = useState(initial), [lastSelection, setLastSelection] = useState(), 
+    /**
+     * Check if item is selected.
+     * @param {object} item Item.
+     * @returns {boolean} Whether item is selected.
+     */
+    isItemSelected = useCallback((item) => selectedItems.includes(item), [selectedItems]), 
+    /**
+     * Check if group is selected.
+     * @param {object} group Group.
+     * @returns {boolean} Whether group is selected.
+     */
+    isGroupSelected = useCallback((group) => group?.items?.every(isItemSelected), [isItemSelected]), 
+    /**
+     * Check if item.group is selected.
+     * @param {object} item Item.
+     * @returns {boolean} Whether item is selected.
+     */
+    isSelected = useCallback((item) => isItemSelected(item) || isGroupSelected(item), [isItemSelected, isGroupSelected]), 
+    /**
+     * Add an item/group to the list of selected items.
+     * @param {object} item Item to select.
+     * @returns {void}
+     */
+    select = useCallback((item) => {
+        const items = item.items ?? [item];
+        setSelectedItems((selection) => [
+            ...selection,
+            ...items.filter((i) => !selection.includes(i)),
+        ]);
+        setLastSelection(item);
+    }, []), 
+    /**
+     * Removes an item/group from the list of selected items.
+     * @param {object} item Item to select.
+     * @returns {void}
+     */
+    deselect = useCallback((item) => {
+        const items = item.items ?? [item];
+        setSelectedItems((selection) => selection.filter((i) => !items.includes(i)));
+        setLastSelection(item);
+    }, []), selectOnly = useCallback((item) => {
+        setSelectedItems(item.items?.slice() || [item]);
+        setLastSelection(item);
+    }, []), 
+    /**
+     * Select all items.
+     * @returns {void}
+     */
+    selectAll = useCallback(() => {
+        setSelectedItems(data.flatMap((item) => item.items || item));
+        setLastSelection(undefined);
+    }, [data]), 
+    /**
+     * Deselect all selected items.
+     * @returns {void}
+     */
+    deselectAll = useCallback(() => {
+        setSelectedItems([]);
+        setLastSelection(undefined);
+    }, []), 
+    /**
+     * Toggles the selection of an item/group.
+     * @param {object} item Item to select.
+     * @param {boolean=} selected Select or deselect, fallback to toggling.
+     * @returns {void}
+     */
+    toggleSelect = useCallback((item, selected = !isSelected(item)) => selected ? select(item) : deselect(item), [isSelected]), toggleSelectTo = useCallback((item, selected) => {
+        const last = lastSelection
+            ? flatData.findIndex((i) => compareItemsFn(i, lastSelection))
+            : -1;
+        if (last < 0) {
+            return toggleSelect(item, selected);
+        }
+        const [from, to] = [last, flatData.indexOf(item)].sort((a, b) => a - b);
+        flatData.slice(from, to + 1).forEach((item, i, items) => {
+            if (i > 0 && i < items.length - 1 && isGroup(item)) {
+                return;
+            }
+            toggleSelect(item, selected);
+        });
+        setLastSelection(item);
+    }, [flatData, compareItemsFn, toggleSelect]);
+    // keep selected items across data updates
+    useEffect(() => setSelectedItems((selectedItems) => selectedItems.length > 0
+        ? flatData.filter((i) => selectedItems.find((item) => compareItemsFn(i, item)))
+        : selectedItems), [flatData]);
+    return {
+        selectedItems,
+        isItemSelected,
+        isGroupSelected,
+        isSelected,
+        select,
+        deselect,
+        selectOnly,
+        selectAll,
+        deselectAll,
+        toggleSelect,
+        toggleSelectTo,
+    };
+};
+//# sourceMappingURL=use-selected-items.js.map

package/dist/grouped-list/use-weak-state.d.ts

@@ -0,0 +1,6 @@
+export function useWeakState(): {
+    setItemState: (item: any, newItemState: any) => void;
+    state: WeakMap<object, any>;
+    signal: WeakMap<object, any>[];
+};
+//# sourceMappingURL=use-weak-state.d.ts.map

package/dist/grouped-list/use-weak-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-weak-state.d.ts","sourceRoot":"","sources":["../../src/grouped-list/use-weak-state.js"],"names":[],"mappings":"AAGO;;;;EAiBN"}

package/dist/grouped-list/use-weak-state.js

@@ -0,0 +1,15 @@
+import { useCallback, useState } from '@pionjs/pion';
+import { callFn, getItemState } from './utils';
+export const useWeakState = () => {
+    const [wrapper, setState] = useState(() => [new WeakMap()]), setItemState = useCallback((item, newItemState) => setState(([state]) => {
+        const itemState = getItemState(item, state);
+        Object.assign(itemState, callFn(newItemState, itemState));
+        return [state];
+    }), []);
+    return {
+        setItemState,
+        state: wrapper[0],
+        signal: wrapper,
+    };
+};
+//# sourceMappingURL=use-weak-state.js.map

package/dist/grouped-list/utils.d.ts

@@ -0,0 +1,11 @@
+export namespace symbols {
+    let group: symbol;
+}
+export function prepareData(data: any, displayEmptyGroups: any, itemsState: any): any;
+export function getItemState(item: any, itemsState: any): any;
+export function isExpanded(item: any, itemsState: any): boolean;
+export function isFolded(group: any, itemsState: any): boolean;
+export function isGroup(item: any): boolean;
+export function callFn(fn: any, ...args: any[]): any;
+export function byReference(a: any, b: any): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/grouped-list/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/grouped-list/utils.js"],"names":[],"mappings":";;;AAAA,sFA6EgC;AA7EhC,8DA6EgC;AA7EhC,gEA6EgC;AA7EhC,+DA6EgC;AA7EhC,4CA6EgC;AA7EhC,qDA6EgC;AA7EhC,qDA6EgC"}

package/dist/grouped-list/utils.js

@@ -0,0 +1,57 @@
+const symbols = {
+    group: Symbol('group'),
+}, getItemState = (item, itemsState) => {
+    if (!itemsState.has(item)) {
+        itemsState.set(item, {});
+    }
+    return itemsState.get(item);
+}, isExpanded = (item, itemsState) => Boolean(getItemState(item, itemsState).expanded), isFolded = (group, itemsState) => Boolean(getItemState(group, itemsState).folded), isGroup = (item) => (item ? item.items instanceof Array : false), 
+/**
+ * Asserts that data is either all items or all groups, never mixed.
+ * @param	 {Array} data the data
+ * @return {void}
+ */
+_assertDataIsHomogeneous = (data) => {
+    if (!Array.isArray(data) || data.length === 0) {
+        return;
+    }
+    const firstItemIsAGroup = Array.isArray(data[0].items), isHomogeneous = data.every((group) => Array.isArray(group.items) === firstItemIsAGroup);
+    if (!isHomogeneous) {
+        throw new Error('Data must be homogeneous.');
+    }
+}, 
+/**
+ * Prepare data.
+ * @param {array} data Data.
+ * @param {boolean} displayEmptyGroups Flag.
+ * @param {WeakMap} itemsState State.
+ * @returns {void|array} Prepared data.
+ */
+prepareData = (data, displayEmptyGroups, itemsState) => {
+    if (!Array.isArray(data)) {
+        return;
+    }
+    // data should be either all items or all grouped items, never mixed
+    _assertDataIsHomogeneous(data);
+    const flatData = data.reduce((acc, item) => {
+        // simple items
+        if (!item.items) {
+            return acc.concat(item);
+        }
+        // groups with items
+        if (item.items.length) {
+            if (getItemState(item, itemsState).folded) {
+                return acc.concat(item);
+            }
+            return acc.concat(item, item.items.map((i) => Object.assign(i, { [symbols.group]: item })));
+        }
+        // groups without items
+        if (displayEmptyGroups) {
+            return acc.concat(item);
+        }
+        return acc;
+    }, []);
+    return flatData;
+}, callFn = (fn, ...args) => (typeof fn === 'function' ? fn(...args) : fn), byReference = (a, b) => a === b;
+export { symbols, prepareData, getItemState, isExpanded, isFolded, isGroup, callFn, byReference, };
+//# sourceMappingURL=utils.js.map

package/dist/lib/compute-layout.d.ts

@@ -0,0 +1,3 @@
+export function computeLayout(_columnConfigs: any, canvasWidth: any, numColumns: any): any;
+export function toCss(layout: any, config: any): any;
+//# sourceMappingURL=compute-layout.d.ts.map

package/dist/lib/compute-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-layout.d.ts","sourceRoot":"","sources":["../../src/lib/compute-layout.js"],"names":[],"mappings":"AAwCO,2FAiCkE;AAjClE,qDAiCkE"}