@vuu-ui/vuu-datatable 0.13.7 → 0.13.9

package/cjs/index.js

@@ -1,16 +1,747 @@
 'use strict';
 
-var FilterTable = require('./filter-table/FilterTable.js');
-var usePersistFilterState = require('./filter-table/usePersistFilterState.js');
-var JsonTable = require('./json-table/JsonTable.js');
-var TreeTable = require('./tree-table/TreeTable.js');
-var LinkedTableView = require('./linked-table-view/LinkedTableView.js');
+var jsxRuntime = require('react/jsx-runtime');
+var vuuFilters = require('@vuu-ui/vuu-filters');
+var vuuTable = require('@vuu-ui/vuu-table');
+var styles = require('@salt-ds/styles');
+var window = require('@salt-ds/window');
+var cx = require('clsx');
+var react = require('react');
+var vuuLayout = require('@vuu-ui/vuu-layout');
+var vuuShell = require('@vuu-ui/vuu-shell');
+var vuuUtils = require('@vuu-ui/vuu-utils');
+var vuuDataLocal = require('@vuu-ui/vuu-data-local');
+var vuuUiControls = require('@vuu-ui/vuu-ui-controls');
+var core = require('@salt-ds/core');
 
+const useFilterTable = ({
+  FilterBarProps: FilterBarProps2,
+  TableProps: {
+    config: { columns },
+    dataSource
+  }
+}) => {
+  const handleApplyFilter = react.useCallback(
+    (filter) => {
+      dataSource.filter = filter;
+    },
+    [dataSource]
+  );
+  const filterBarProps = {
+    ...FilterBarProps2,
+    columnDescriptors: FilterBarProps2?.columnDescriptors ?? columns,
+    onApplyFilter: handleApplyFilter
+  };
+  return {
+    filterBarProps
+  };
+};
 
+var filterTableCss = ".vuuFilterTable {\n  --vuuMeasuredContainer-flex: 1 1 auto;\n  --vuuMeasuredContainer-height: auto;\n  display: flex;\n  flex-direction: column;\n\n  .vuuFilterBar {\n    flex: 0 0 auto;\n  }\n}\n";
 
-exports.FilterTable = FilterTable.FilterTable;
-exports.usePersistFilterState = usePersistFilterState.usePersistFilterState;
-exports.JsonTable = JsonTable.JsonTable;
-exports.TreeTable = TreeTable.TreeTable;
-exports.LinkedTableView = LinkedTableView.LinkedTableView;
+const classBase$1 = "vuuFilterTable";
+const FilterTable = ({
+  FilterBarProps: FilterBarProps2,
+  TableProps: TableProps2,
+  style: styleProps,
+  ...htmlAttributes
+}) => {
+  const targetWindow = window.useWindow();
+  styles.useComponentCssInjection({
+    testId: "vuu-filter-table",
+    css: filterTableCss,
+    window: targetWindow
+  });
+  const { filterBarProps } = useFilterTable({
+    TableProps: TableProps2,
+    FilterBarProps: FilterBarProps2
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ...htmlAttributes,
+      className: cx(classBase$1),
+      style: { ...styleProps },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(vuuFilters.FilterBar, { ...filterBarProps }),
+        /* @__PURE__ */ jsxRuntime.jsx(vuuTable.Table, { ...TableProps2, height: "auto", width: "auto" })
+      ]
+    }
+  );
+};
+
+const NO_CONFIG = {};
+const hasFilterWithName = (filters, name) => filters.findIndex((f) => f.name === name) !== -1;
+const usePersistFilterState = ({
+  tableSchema
+}) => {
+  const { load, save } = vuuLayout.useViewContext();
+  const { getApplicationSettings, saveApplicationSettings } = vuuShell.useWorkspace();
+  const { "filterbar-config": filterbarConfigFromState } = react.useMemo(() => load?.() ?? NO_CONFIG, [load]);
+  const [filterState, setFilterState] = react.useState({
+    filters: filterbarConfigFromState?.filterState?.filters ?? [],
+    activeIndices: filterbarConfigFromState?.filterState?.activeIndices ?? []
+  });
+  const savedFilters = react.useMemo(() => {
+    const {
+      table: { module, table }
+    } = tableSchema;
+    const savedFilters2 = getApplicationSettings("filters");
+    const key = `${module}:${table}`;
+    return savedFilters2?.[key] ?? [];
+  }, [getApplicationSettings, tableSchema]);
+  const removeFilterFromSettings = react.useCallback(
+    (filter) => {
+      if (!tableSchema || !filter.name) return;
+      const savedFilters2 = getApplicationSettings("filters");
+      if (!savedFilters2) return;
+      const { module, table } = tableSchema.table;
+      const key = `${module}:${table}`;
+      if (hasFilterWithName(savedFilters2[key], filter.name)) {
+        const newSavedFilters = {
+          ...savedFilters2,
+          [key]: savedFilters2[key].filter((f) => f.name !== filter.name)
+        };
+        saveApplicationSettings(newSavedFilters, "filters");
+      }
+    },
+    [getApplicationSettings, saveApplicationSettings, tableSchema]
+  );
+  const saveFilterToSettings = react.useCallback(
+    (filter, name) => {
+      if (tableSchema && name) {
+        const savedFilters2 = getApplicationSettings(
+          "filters"
+        );
+        let newFilters = savedFilters2;
+        const { module, table } = tableSchema.table;
+        const key = `${module}:${table}`;
+        if (savedFilters2) {
+          if (savedFilters2[key]) {
+            if (hasFilterWithName(savedFilters2[key], name)) {
+              newFilters = {
+                ...savedFilters2,
+                [key]: savedFilters2[key].map(
+                  (f) => f.name === name ? { ...filter, name } : f
+                )
+              };
+            } else if (filter?.name && filter?.name !== name && hasFilterWithName(savedFilters2[key], filter.name)) {
+              newFilters = {
+                ...savedFilters2,
+                [key]: savedFilters2[key].map(
+                  (f) => f.name === filter.name ? { ...filter, name } : f
+                )
+              };
+            } else {
+              newFilters = {
+                ...savedFilters2,
+                [key]: savedFilters2[key].concat({ ...filter, name })
+              };
+            }
+          } else {
+            newFilters = {
+              ...savedFilters2,
+              [key]: [{ ...filter, name }]
+            };
+          }
+        } else {
+          newFilters = {
+            [key]: [{ ...filter, name }]
+          };
+        }
+        if (newFilters !== savedFilters2) {
+          saveApplicationSettings(newFilters, "filters");
+        }
+      }
+    },
+    [getApplicationSettings, saveApplicationSettings, tableSchema]
+  );
+  const handleFilterStateChanged = react.useCallback(
+    (filterState2) => {
+      save?.({ filterState: filterState2 }, "filterbar-config");
+      setFilterState(filterState2);
+    },
+    [save]
+  );
+  const handleFilterDeleted = react.useCallback(
+    (filter) => {
+      removeFilterFromSettings(filter);
+    },
+    [removeFilterFromSettings]
+  );
+  const handleFilterRenamed = react.useCallback(
+    (filter, name) => {
+      saveFilterToSettings(filter, name);
+    },
+    [saveFilterToSettings]
+  );
+  const buildFilterTableMenuOptions = react.useCallback(
+    (location) => {
+      if (location === "filter-bar-menu") {
+        if (savedFilters.length > 0) {
+          return savedFilters.map((filter) => ({
+            id: "add-filter",
+            label: filter.name,
+            options: { filter }
+          }));
+        } else {
+          return [
+            {
+              label: `You have no saved filters for this table`,
+              id: `no-action`
+            }
+          ];
+        }
+      } else {
+        return [];
+      }
+    },
+    [savedFilters]
+  );
+  const handleFilterTableMenuAction = react.useCallback(
+    (menuItemId) => {
+      if (menuItemId === "add-filter") {
+        return true;
+      } else {
+        return false;
+      }
+    },
+    []
+  );
+  return {
+    buildFilterTableMenuOptions,
+    filterState,
+    handleFilterTableMenuAction,
+    onFilterStateChanged: handleFilterStateChanged,
+    onFilterDeleted: handleFilterDeleted,
+    onFilterRenamed: handleFilterRenamed
+  };
+};
+
+var arrayCellCss = ".vuuJsonCell {\n  --group-cell-spacer-width: 20px;\n  align-items: center;\n  border-right-style: solid;\n  border-right-width: 1px;\n  cursor: pointer;\n  display: inline-flex;\n  height: var(--row-height);\n  padding-left: 20px;\n  line-height: 16px;\n  position: relative;\n\n  .vuuToggleIconButton {\n    position: absolute;\n  }\n}\n";
+
+const { IS_EXPANDED, IS_LEAF: IS_LEAF$1 } = vuuUtils.metadataKeys;
+const JsonCell = ({ column, columnMap, row }) => {
+  const targetWindow = window.useWindow();
+  styles.useComponentCssInjection({
+    testId: "vuu-array-cell",
+    css: arrayCellCss,
+    window: targetWindow
+  });
+  const { name } = column;
+  const dataIdx = columnMap[name];
+  let { [IS_EXPANDED]: isExpanded, [IS_LEAF$1]: isLeaf, [dataIdx]: value } = row;
+  const getDisplayValue = () => {
+    if (isLeaf) {
+      return value;
+    } else if (typeof value === "string" && value.endsWith("{")) {
+      value = value.slice(0, -1);
+      if (!isNaN(parseInt(value))) {
+        return `${value}: {...}`;
+      } else {
+        return `value {...}`;
+      }
+    } else if (typeof value === "string" && value.endsWith("[")) {
+      value = value.slice(0, -1);
+      return `${value} [...]`;
+    }
+  };
+  const displayValue = getDisplayValue();
+  const isEmpty = displayValue === "" || displayValue === void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    isLeaf || isEmpty ? null : /* @__PURE__ */ jsxRuntime.jsx(vuuUiControls.ToggleIconButton, { isExpanded }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { children: displayValue })
+  ] });
+};
+
+vuuUtils.registerComponent("json", JsonCell, "cell-renderer");
+const JsonTable = ({
+  config,
+  source: sourceProp,
+  ...tableProps
+}) => {
+  const sourceRef = react.useRef(sourceProp);
+  const dataSourceRef = react.useRef(void 0);
+  react.useMemo(() => {
+    dataSourceRef.current = new vuuDataLocal.JsonDataSource({
+      data: sourceRef.current
+    });
+  }, []);
+  const tableConfig = react.useMemo(() => {
+    return {
+      ...config,
+      columns: dataSourceRef.current?.columnDescriptors ?? [],
+      columnSeparators: true,
+      rowSeparators: true
+    };
+  }, [config]);
+  react.useEffect(() => {
+    if (dataSourceRef.current) {
+      dataSourceRef.current.data = sourceProp;
+    }
+  }, [sourceProp]);
+  if (dataSourceRef.current === void 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    vuuTable.Table,
+    {
+      ...tableProps,
+      config: tableConfig,
+      dataSource: dataSourceRef.current,
+      showColumnHeaderMenus: false,
+      selectionModel: "none"
+    }
+  );
+};
+
+const { DEPTH, IS_LEAF, KEY, IDX } = vuuUtils.metadataKeys;
+const rowToTreeNodeObject = (row, columnMap) => {
+  const { [IS_LEAF]: isLeaf, [KEY]: key, [IDX]: index, [DEPTH]: depth } = row;
+  const firstColIdx = columnMap.nodeData;
+  const labelColIdx = firstColIdx + depth;
+  return {
+    key,
+    index,
+    isGroupRow: !isLeaf,
+    isSelected: vuuUtils.isRowSelected(row),
+    data: {
+      label: row[labelColIdx],
+      nodeData: row[firstColIdx]
+    }
+  };
+};
+const TreeTable = ({
+  config,
+  dataSource,
+  source,
+  ...tableProps
+}) => {
+  const dataSourceRef = react.useRef(void 0);
+  react.useMemo(() => {
+    if (dataSource) {
+      dataSourceRef.current = dataSource;
+    } else if (source) {
+      dataSourceRef.current = new vuuDataLocal.TreeDataSource({
+        data: source
+      });
+    } else {
+      throw Error(`TreeTable either source or dataSource must be provided`);
+    }
+  }, [dataSource, source]);
+  const tableConfig = react.useMemo(() => {
+    return {
+      ...config,
+      columns: dataSourceRef.current?.columnDescriptors ?? [],
+      columnSeparators: false,
+      rowSeparators: false
+    };
+  }, [config]);
+  console.log({ tableConfig, dataSource: dataSourceRef.current });
+  if (dataSourceRef.current === void 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    vuuTable.Table,
+    {
+      ...tableProps,
+      className: "vuuTreeTable",
+      config: tableConfig,
+      dataSource: dataSourceRef.current,
+      groupToggleTarget: "toggle-icon",
+      navigationStyle: "tree",
+      rowToObject: rowToTreeNodeObject,
+      showColumnHeaderMenus: false,
+      selectionModel: "single",
+      selectionBookendWidth: 0
+    }
+  );
+};
+
+const getSchema = (schemas, { module, table }) => {
+  const schema = schemas.find(
+    ({ table: t }) => t.module === module && t.table === table
+  );
+  if (schema) {
+    return schema;
+  } else {
+    throw Error(`No schema for table ${module} ${table}`);
+  }
+};
+const getTable = (ds) => {
+  if (ds.table) {
+    return ds.table;
+  } else {
+    throw Error("No datasource table specified");
+  }
+};
+const getTables = (linkedDataSources) => {
+  const { "1": linked1, "2": linked2, "3": linked3 } = linkedDataSources;
+  const tables = [];
+  tables.push(getTable(linked1.dataSource));
+  if (Array.isArray(linked2)) {
+    linked2.forEach(({ dataSource }) => {
+      tables.push(getTable(dataSource));
+    });
+  } else {
+    tables.push(getTable(linked2.dataSource));
+  }
+  if (Array.isArray(linked3)) {
+    linked3.forEach(({ dataSource }) => {
+      tables.push(getTable(dataSource));
+    });
+  } else if (linked3) {
+    tables.push(getTable(linked3.dataSource));
+  }
+  return tables;
+};
+const useLinkedTableView = ({
+  linkedDataSources
+}) => {
+  const { VuuDataSource, getServerAPI } = vuuUtils.useData();
+  const [tableConfig, setTableConfig] = react.useState();
+  const [activeTabs, setActiveTab] = react.useState([
+    0,
+    0,
+    0
+  ]);
+  const [collapsed, setCollapsed] = react.useState([
+    false,
+    false
+  ]);
+  const [tabbedView, setTabbedView] = react.useState([1, 1]);
+  react.useMemo(async () => {
+    const tables = getTables(linkedDataSources);
+    const serverAPI = await getServerAPI();
+    const schemas = await Promise.all(tables.map(serverAPI.getTableSchema));
+    const isDataSource = (ds) => typeof ds === typeof VuuDataSource;
+    const getDataSource = (ds) => {
+      if (isDataSource(ds)) {
+        return ds;
+      } else {
+        return new VuuDataSource(ds);
+      }
+    };
+    const createVisualLink = (vuuLink, parentDs) => {
+      if (parentDs && parentDs.table) {
+        const parentVpId = parentDs.viewport;
+        const toTable = vuuLink.toTable ?? parentDs.table?.table;
+        return {
+          link: {
+            ...vuuLink,
+            toTable
+          },
+          parentClientVpId: parentVpId,
+          parentVpId
+        };
+      } else {
+        throw Error("visual link cannot be created without parent vp id");
+      }
+    };
+    const getLinkedDataSource = (ds, vuuLink, parentDs) => {
+      if (isDataSource(ds)) {
+        return ds;
+      } else {
+        return new VuuDataSource({
+          ...ds,
+          visualLink: createVisualLink(vuuLink, parentDs)
+        });
+      }
+    };
+    const getTableConfig = (ds) => {
+      const schema = getSchema(schemas, getTable(ds));
+      return {
+        columns: schema.columns
+      };
+    };
+    const getRootConfig = ({
+      dataSource: ds,
+      title
+    }) => ({
+      config: getTableConfig(ds),
+      dataSource: getDataSource(ds),
+      title
+    });
+    const getLinkedConfig = ({ dataSource: ds, vuuLink, title }, parentDataSource) => ({
+      config: getTableConfig(ds),
+      dataSource: getLinkedDataSource(ds, vuuLink, parentDataSource),
+      title
+    });
+    const getLinkedConfigs = (linkedTableConfig, parentDataSource) => {
+      if (Array.isArray(linkedTableConfig)) {
+        return linkedTableConfig.map(
+          (config) => getLinkedConfig(config, parentDataSource)
+        );
+      } else {
+        return getLinkedConfig(linkedTableConfig, parentDataSource);
+      }
+    };
+    const { "1": level1, "2": level2, "3": level3 } = linkedDataSources;
+    const configLevel1 = getRootConfig(level1);
+    const configLevel2 = getLinkedConfigs(level2, configLevel1.dataSource);
+    const dsLevel2 = Array.isArray(configLevel2) ? void 0 : configLevel2.dataSource;
+    const configLevel3 = level3 ? getLinkedConfigs(level3, dsLevel2) : void 0;
+    const results = {
+      "1": configLevel1,
+      "2": configLevel2,
+      "3": configLevel3
+    };
+    setTableConfig(results);
+  }, [VuuDataSource, getServerAPI, linkedDataSources]);
+  const handleTabChangeLevel1 = react.useCallback((tabIndex) => {
+    setActiveTab(([, v2, v3]) => [tabIndex, v2, v3]);
+  }, []);
+  const handleTabChangeLevel2 = react.useCallback((tabIndex) => {
+    setActiveTab(([v1, , v3]) => [v1, tabIndex, v3]);
+  }, []);
+  const handleTabChangeLevel3 = react.useCallback((tabIndex) => {
+    setActiveTab(([v1, v2]) => [v1, v2, tabIndex]);
+  }, []);
+  const handleCollapseLevel2 = react.useCallback(() => {
+    setCollapsed(([, val]) => [true, val]);
+  }, []);
+  const handleExpandLevel2 = react.useCallback(() => {
+    setCollapsed(([, val]) => [false, val]);
+  }, []);
+  const handleCollapseLevel3 = react.useCallback(() => {
+    setCollapsed(([val]) => [val, true]);
+  }, []);
+  const handleExpandLevel3 = react.useCallback(() => {
+    setCollapsed(([val]) => [val, false]);
+  }, []);
+  const handleChangeTabbedView2 = react.useCallback(
+    (evt) => {
+      const target = evt.target;
+      const button = target?.closest("button");
+      if (button) {
+        const value = parseInt(button.value);
+        setTabbedView(([, val]) => [value, val]);
+      }
+    },
+    []
+  );
+  const handleChangeTabbedView3 = react.useCallback(
+    (evt) => {
+      const target = evt.target;
+      const button = target?.closest("button");
+      if (button) {
+        const value = parseInt(button.value);
+        setTabbedView(([val]) => [val, value]);
+      }
+    },
+    []
+  );
+  return {
+    level1: {
+      activeTab: activeTabs[0],
+      key: "level1",
+      onTabChange: handleTabChangeLevel1
+    },
+    level2: {
+      activeTab: activeTabs[1],
+      collapsed: collapsed[0],
+      key: "level2",
+      onChangeTabbedView: handleChangeTabbedView2,
+      onCollapse: handleCollapseLevel2,
+      onExpand: handleExpandLevel2,
+      onTabChange: handleTabChangeLevel2,
+      tabbedView: tabbedView[0]
+    },
+    level3: {
+      activeTab: activeTabs[2],
+      collapsed: collapsed[1],
+      key: "level3",
+      onChangeTabbedView: handleChangeTabbedView3,
+      onCollapse: handleCollapseLevel3,
+      onExpand: handleExpandLevel3,
+      onTabChange: handleTabChangeLevel3,
+      tabbedView: tabbedView[1]
+    },
+    tableConfig
+  };
+};
+
+var css = ".vuuLinkedTableView {\n    \n}\n\n.vuuLinkedTableView-header {\n    align-items: center;\n    \n    display: flex;\n    flex-basis: 28px;\n    flex-grow: 0;\n    flex-shrink: 0;\n    padding-right: var(--salt-spacing-100);\n\n    .vuuTabstrip {\n        width: fit-content;\n    }\n\n    .vuuLinkedTableView-toolTray {\n        margin-left: auto;\n    }\n\n}\n\n.vuuLinkedTableView-view {\n    overflow: hidden;\n    padding: var(--salt-spacing-100);\n}";
+
+const TableLayoutToggleButton = (props) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(core.ToggleButtonGroup, { ...props, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      core.ToggleButton,
+      {
+        className: "vuuIconToggleButton",
+        value: 0,
+        "aria-label": "Tabbed View",
+        children: /* @__PURE__ */ jsxRuntime.jsx(vuuUiControls.Icon, { name: "split-v", size: 18 })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      core.ToggleButton,
+      {
+        className: "vuuIconToggleButton",
+        value: 1,
+        "aria-label": "Side by side view",
+        children: /* @__PURE__ */ jsxRuntime.jsx(vuuUiControls.Icon, { name: "tabs", size: 18 })
+      }
+    )
+  ] });
+};
+
+const classBase = "vuuLinkedTableView";
+const LinkedTables = ({
+  className,
+  linkedDataSources,
+  ...htmlAttributes
+}) => {
+  const targetWindow = window.useWindow();
+  styles.useComponentCssInjection({
+    testId: "vuu-linked-table-view",
+    css,
+    window: targetWindow
+  });
+  const { tableConfig, ...config } = useLinkedTableView({
+    linkedDataSources
+  });
+  const getLinkedTables = (tdsConfig, {
+    activeTab,
+    onChangeTabbedView,
+    onTabChange,
+    tabbedView,
+    ...levelConfig
+  }) => Array.isArray(tdsConfig) === false ? /* @__PURE__ */ jsxRuntime.jsx(
+    vuuLayout.View,
+    {
+      ...levelConfig,
+      header: true,
+      resizeable: true,
+      style: { flexBasis: 0, flexGrow: 1, flexShrink: 1 },
+      title: tdsConfig.title,
+      children: /* @__PURE__ */ jsxRuntime.jsx(vuuTable.Table, { config: tdsConfig.config, dataSource: tdsConfig.dataSource })
+    }
+  ) : tabbedView === 1 ? /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        flexBasis: 0,
+        flexGrow: 1,
+        flexShrink: 1
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `${classBase}-header`, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(vuuUiControls.Tabstrip, { activeTabIndex: activeTab, onActiveChange: onTabChange, children: tdsConfig.map(({ title }, i) => /* @__PURE__ */ jsxRuntime.jsx(vuuUiControls.Tab, { label: title }, i)) }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: `${classBase}-toolTray`, children: /* @__PURE__ */ jsxRuntime.jsx(
+            TableLayoutToggleButton,
+            {
+              onChange: onChangeTabbedView,
+              value: tabbedView
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          vuuLayout.Stack,
+          {
+            active: activeTab,
+            "data-resizeable": true,
+            showTabs: false,
+            style: { flexBasis: 0, flexGrow: 1, flexShrink: 1 },
+            children: tdsConfig.map(({ config: config2, dataSource, title }, i) => /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                className: `${classBase}-view`,
+                style: { flexBasis: 0, flexGrow: 1, flexShrink: 1 },
+                title,
+                children: /* @__PURE__ */ jsxRuntime.jsx(vuuTable.Table, { config: config2, dataSource })
+              },
+              i
+            ))
+          },
+          levelConfig.key
+        )
+      ]
+    }
+  ) : /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        flexBasis: 0,
+        flexGrow: 1,
+        flexShrink: 1
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `${classBase}-header`, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: `${classBase}-flexHeaders`, children: tdsConfig.map(({ title }, i) => /* @__PURE__ */ jsxRuntime.jsx("span", { children: title }, i)) }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: `${classBase}-toolTray`, children: /* @__PURE__ */ jsxRuntime.jsx(
+            TableLayoutToggleButton,
+            {
+              onChange: onChangeTabbedView,
+              value: tabbedView
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          vuuLayout.Flexbox,
+          {
+            style: {
+              flexDirection: "row",
+              flexBasis: 0,
+              flexGrow: 1,
+              flexShrink: 1
+            },
+            children: tdsConfig.map(({ config: config2, dataSource, title }, i) => /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                className: `${classBase}-view`,
+                "data-resizeable": true,
+                style: { flexBasis: 0, flexGrow: 1, flexShrink: 1 },
+                title,
+                children: /* @__PURE__ */ jsxRuntime.jsx(vuuTable.Table, { config: config2, dataSource })
+              },
+              i
+            ))
+          }
+        )
+      ]
+    }
+  );
+  const getAllLinkedTables = (level2, level3, config2) => {
+    const results = [getLinkedTables(level2, config2.level2)];
+    if (level3) {
+      results.push(getLinkedTables(level3, config2.level3));
+    }
+    return results;
+  };
+  if (tableConfig) {
+    const { "1": level1, "2": level2, "3": level3 } = tableConfig;
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { ...htmlAttributes, className: cx(classBase, className), children: /* @__PURE__ */ jsxRuntime.jsxs(vuuLayout.Flexbox, { style: { flexDirection: "column", height: "100%" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        vuuLayout.View,
+        {
+          className: `${classBase}-view`,
+          header: true,
+          resizeable: true,
+          style: { flexBasis: 0, flexGrow: 1, flexShrink: 1 },
+          title: level1.title,
+          children: /* @__PURE__ */ jsxRuntime.jsx(vuuTable.Table, { config: level1.config, dataSource: level1.dataSource })
+        }
+      ),
+      ...getAllLinkedTables(level2, level3, config)
+    ] }) });
+  } else {
+    return null;
+  }
+};
+const LinkedTableView = ({
+  className,
+  linkedDataSources,
+  ...htmlAttributes
+}) => /* @__PURE__ */ jsxRuntime.jsx(vuuLayout.View, { ...htmlAttributes, className, children: /* @__PURE__ */ jsxRuntime.jsx(LinkedTables, { linkedDataSources }) });
+
+exports.FilterTable = FilterTable;
+exports.JsonTable = JsonTable;
+exports.LinkedTableView = LinkedTableView;
+exports.TreeTable = TreeTable;
+exports.usePersistFilterState = usePersistFilterState;
 //# sourceMappingURL=index.js.map