@affino/datagrid-vue-app 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,4 +1,1125 @@
-import DataGridComponent from "./DataGrid";
-export const DataGrid = DataGridComponent;
-export { clearDataGridSavedViewInStorage, migrateDataGridSavedView, parseDataGridSavedView, readDataGridSavedViewFromStorage, serializeDataGridSavedView, writeDataGridSavedViewToStorage, } from "./config/dataGridSavedView";
-export { default } from "./DataGrid";
+import { defineComponent as ae, ref as X, provide as ge, computed as g, watch as w, onBeforeUnmount as Z, h as Y, mergeProps as ve, toRef as te } from "vue";
+import { useDataGridRuntime as ye, useDataGridAppSelection as pe, useDataGridAppRowSelection as we } from "@affino/datagrid-vue";
+import { f as Se, z as he, A as be, B as Re, h as Me, C as Oe, u as Be, D as Ae } from "./chunks/useDataGridAppRowModel-CcTL-h8L.js";
+import { applyGridTheme as Ce, resolveGridThemeTokens as Pe, defaultStyleConfig as B, sugarTheme as ie, industrialNeutralTheme as oe } from "@affino/datagrid-theme";
+const Ge = {
+  default: B,
+  "industrial-neutral": oe,
+  industrialNeutral: oe,
+  sugar: ie
+};
+function De(e, t) {
+  if (!e && !t)
+    return;
+  const r = {
+    ...e ?? {}
+  };
+  for (const [n, f] of Object.entries(t ?? {}))
+    r[n] = {
+      ...r[n] ?? {},
+      ...f
+    };
+  return r;
+}
+function _(e, t) {
+  return {
+    ...e,
+    ...t,
+    grid: { ...e.grid ?? {}, ...t.grid ?? {} },
+    header: { ...e.header ?? {}, ...t.header ?? {} },
+    body: { ...e.body ?? {}, ...t.body ?? {} },
+    group: { ...e.group ?? {}, ...t.group ?? {} },
+    summary: { ...e.summary ?? {}, ...t.summary ?? {} },
+    state: { ...e.state ?? {}, ...t.state ?? {} },
+    tokens: { ...e.tokens ?? {}, ...t.tokens ?? {} },
+    tokenVariants: De(e.tokenVariants, t.tokenVariants)
+  };
+}
+function xe(e) {
+  return !e || typeof e != "object" ? !1 : "tokens" in e || "tokenVariants" in e || "activeTokenVariant" in e || "defaultTokenVariant" in e || "inheritThemeFromDocument" in e || "documentDarkClass" in e || "grid" in e || "header" in e || "body" in e || "group" in e || "summary" in e || "state" in e;
+}
+function Ie(e) {
+  return e == null ? B : typeof e == "string" ? e === "sugar" ? _(B, ie) : Ge[e] ?? B : xe(e) ? _(B, e) : _(B, {
+    tokens: e
+  });
+}
+function Le(e) {
+  const t = Ie(e);
+  return Pe(t ?? B, {
+    document: typeof document > "u" ? void 0 : document
+  });
+}
+function ne(e, t) {
+  const r = Le(t);
+  return Ce(e, r), r;
+}
+function re(e, t) {
+  return Number.isFinite(e) ? Math.max(0, Math.trunc(e)) : t;
+}
+function le(e, t) {
+  return Number.isFinite(e) ? Math.max(1, Math.trunc(e)) : t;
+}
+function je(e) {
+  if (e !== void 0) {
+    if (e == null)
+      return null;
+    if (typeof e == "string") {
+      const t = e.trim();
+      return t ? { fields: [t], expandedByDefault: !0 } : null;
+    }
+    if (Array.isArray(e)) {
+      const t = e.map((r) => r.trim()).filter((r) => r.length > 0);
+      return t.length > 0 ? { fields: [...t], expandedByDefault: !0 } : null;
+    }
+    return e;
+  }
+}
+function Ke(e, t) {
+  return t === !0 || t && typeof t == "object" ? "pagination" : e ?? "virtualization";
+}
+function Fe(e, t, r, n) {
+  if (t !== "pagination")
+    return null;
+  const f = 100, u = le(r, f), p = re(n, 0);
+  return e === !0 || e === !1 || e == null ? {
+    pageSize: u,
+    currentPage: p
+  } : {
+    pageSize: le(r ?? e.pageSize, f),
+    currentPage: re(n ?? e.currentPage, 0)
+  };
+}
+const J = "Advanced filter";
+function Te(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    buttonLabel: J
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    buttonLabel: typeof e.buttonLabel == "string" && e.buttonLabel.trim().length > 0 ? e.buttonLabel.trim() : J
+  } : {
+    enabled: !1,
+    buttonLabel: J
+  };
+}
+function We(e) {
+  return typeof e == "object" && e !== null;
+}
+function ue(e, t, r) {
+  const n = We(e) ? e : null, f = t(n && "state" in n ? n.state : e, r);
+  if (!f)
+    return null;
+  const u = n?.viewMode, p = u === "gantt" ? "gantt" : u === "table" ? "table" : void 0;
+  return {
+    state: f,
+    ...p ? { viewMode: p } : {}
+  };
+}
+function ze(e) {
+  return JSON.stringify(e);
+}
+function Ve(e, t, r) {
+  if (typeof e != "string" || e.trim().length === 0)
+    return null;
+  try {
+    return ue(JSON.parse(e), t, r);
+  } catch {
+    return null;
+  }
+}
+function tt(e, t, r) {
+  if (!e || typeof t != "string" || t.trim().length === 0)
+    return !1;
+  try {
+    return e.setItem(t, ze(r)), !0;
+  } catch {
+    return !1;
+  }
+}
+function ot(e, t, r, n) {
+  if (!e || typeof t != "string" || t.trim().length === 0)
+    return null;
+  try {
+    const f = e.getItem(t);
+    return f ? Ve(f, r, n) : null;
+  } catch {
+    return null;
+  }
+}
+function nt(e, t) {
+  if (!e || typeof t != "string" || t.trim().length === 0)
+    return !1;
+  try {
+    return e.removeItem(t), !0;
+  } catch {
+    return !1;
+  }
+}
+const $ = "Columns";
+function He(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    buttonLabel: $
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    buttonLabel: typeof e.buttonLabel == "string" && e.buttonLabel.trim().length > 0 ? e.buttonLabel.trim() : $
+  } : {
+    enabled: !1,
+    buttonLabel: $
+  };
+}
+const q = "Aggregations";
+function Ee(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    buttonLabel: q
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    buttonLabel: typeof e.buttonLabel == "string" && e.buttonLabel.trim().length > 0 ? e.buttonLabel.trim() : q
+  } : {
+    enabled: !1,
+    buttonLabel: q
+  };
+}
+function T(e, t) {
+  return Number.isFinite(e) ? Math.max(0, Math.trunc(e)) : t;
+}
+function ke(e, t) {
+  const r = {
+    rows: !0,
+    columns: !1,
+    rowOverscan: 8,
+    columnOverscan: 2
+  };
+  if (e === !0)
+    r.columns = !0;
+  else if (e === !1)
+    r.rows = !1, r.columns = !1;
+  else if (e && typeof e == "object") {
+    r.rows = e.rows ?? r.rows, r.columns = e.columns ?? r.columns;
+    const n = T(e.overscan, r.rowOverscan);
+    r.rowOverscan = T(e.rowOverscan, n), r.columnOverscan = T(e.columnOverscan, T(e.overscan, r.columnOverscan));
+  }
+  return t === "pagination" && (r.rows = !1), r;
+}
+const Ne = ae({
+  name: "DataGridRuntimeHost",
+  inheritAttrs: !1,
+  props: {
+    rows: {
+      type: Array,
+      default: () => []
+    },
+    rowModel: {
+      type: Object,
+      default: void 0
+    },
+    columns: {
+      type: Array,
+      default: () => []
+    },
+    theme: {
+      type: [String, Object],
+      default: void 0
+    },
+    plugins: {
+      type: Array,
+      default: () => []
+    },
+    services: {
+      type: Object,
+      default: void 0
+    },
+    startupOrder: {
+      type: Array,
+      default: void 0
+    },
+    autoStart: {
+      type: Boolean,
+      default: !0
+    },
+    renderMode: {
+      type: String,
+      default: "virtualization"
+    },
+    pagination: {
+      type: Object,
+      default: null
+    }
+  },
+  emits: ["cell-change", "selection-change"],
+  setup(e, { attrs: t, slots: r, emit: n, expose: f }) {
+    const u = X(null);
+    ge(Se, u);
+    let p = null;
+    const a = ye({
+      rows: g(() => e.rows),
+      rowModel: e.rowModel,
+      columns: g(() => e.columns),
+      plugins: e.plugins,
+      services: e.services,
+      startupOrder: e.startupOrder,
+      autoStart: e.autoStart
+    }), h = a, b = {
+      api: a.api,
+      syncBodyRowsInRange: a.syncBodyRowsInRange,
+      rowPartition: a.rowPartition,
+      virtualWindow: a.virtualWindow,
+      columnSnapshot: a.columnSnapshot,
+      getBodyRowAtIndex: h.getBodyRowAtIndex,
+      resolveBodyRowIndexById: h.resolveBodyRowIndexById
+    }, M = () => {
+      if (e.renderMode === "pagination") {
+        const y = e.pagination ?? { pageSize: 100, currentPage: 0 };
+        a.api.rows.setPagination({
+          pageSize: Math.max(1, Math.trunc(y.pageSize)),
+          currentPage: Math.max(0, Math.trunc(y.currentPage))
+        });
+        return;
+      }
+      a.api.rows.setPagination(null);
+    };
+    w(
+      () => e.renderMode,
+      () => {
+        M();
+      },
+      { immediate: !0 }
+    ), w(
+      () => e.pagination,
+      () => {
+        M();
+      },
+      { immediate: !0, deep: !0 }
+    ), typeof document < "u" && (p = new MutationObserver(() => {
+      const y = u.value;
+      y && ne(y, e.theme);
+    }), p.observe(document.documentElement, {
+      attributes: !0,
+      attributeFilter: ["class", "data-theme"]
+    })), w(
+      [() => e.theme, u],
+      () => {
+        const y = u.value;
+        y && ne(y, e.theme);
+      },
+      { immediate: !0, deep: !0 }
+    );
+    const A = a.api.events.on("rows:changed", (y) => {
+      n("cell-change", y);
+    }), C = a.api.events.on("selection:changed", (y) => {
+      n("selection-change", y);
+    });
+    Z(() => {
+      A(), C(), p?.disconnect(), p = null;
+    });
+    const v = g(() => {
+      const y = a.virtualWindow.value;
+      return {
+        ...y ?? {},
+        rowTotal: y?.rowTotal ?? a.rowPartition.value.bodyRowCount,
+        colTotal: a.columnSnapshot.value.visibleColumns.length
+      };
+    });
+    return f({
+      api: a.api,
+      core: a.core,
+      runtime: b,
+      rowModel: a.rowModel,
+      columnModel: a.columnModel,
+      columnSnapshot: a.columnSnapshot,
+      rowPartition: a.rowPartition,
+      setRows: a.setRows,
+      syncBodyRowsInRange: a.syncBodyRowsInRange,
+      getBodyRowAtIndex: h.getBodyRowAtIndex,
+      resolveBodyRowIndexById: h.resolveBodyRowIndexById,
+      virtualWindow: a.virtualWindow,
+      start: a.start,
+      stop: a.stop
+    }), () => Y(
+      "div",
+      ve(t, {
+        ref: u,
+        class: "affino-datagrid-app-root",
+        style: {
+          display: "flex",
+          flex: "1 1 auto",
+          width: "100%",
+          height: "100%",
+          minHeight: "0",
+          minWidth: "0"
+        }
+      }),
+      r.default?.({
+        api: a.api,
+        core: a.core,
+        runtime: b,
+        grid: b,
+        rowModel: a.rowModel,
+        columnModel: a.columnModel,
+        columnSnapshot: a.columnSnapshot.value,
+        rowPartition: a.rowPartition.value,
+        setRows: a.setRows,
+        syncBodyRowsInRange: a.syncBodyRowsInRange,
+        getBodyRowAtIndex: h.getBodyRowAtIndex,
+        resolveBodyRowIndexById: h.resolveBodyRowIndexById,
+        virtualWindow: v.value
+      }) ?? []
+    );
+  }
+});
+function Q(e) {
+  return Number.isFinite(e) ? Math.max(0, Math.trunc(e)) : null;
+}
+function R(e) {
+  try {
+    return JSON.stringify(e);
+  } catch {
+    return null;
+  }
+}
+function Ue(e) {
+  return e ? {
+    fields: [...e.fields],
+    expandedByDefault: e.expandedByDefault
+  } : null;
+}
+function _e(e) {
+  let t = null, r = null, n = !1, f = null, u = null, p = null, a = null, h = null, b = null, M = null;
+  const A = () => {
+    t?.(), r?.(), t = null, r = null;
+  }, C = () => {
+    const o = e.gridRef.value?.api.columns;
+    if (!o)
+      return null;
+    const d = o.getSnapshot(), i = {}, s = {}, S = {};
+    for (const c of d.columns)
+      i[c.key] = c.visible, s[c.key] = c.width, S[c.key] = c.pin;
+    return {
+      order: [...d.order],
+      visibility: i,
+      widths: s,
+      pins: S
+    };
+  }, v = () => {
+    n || (n = !0, queueMicrotask(() => {
+      n = !1;
+      const o = C(), d = e.gridRef.value?.api;
+      if (o) {
+        const i = R(o);
+        b = i, i !== p && (p = i, e.emit.columnState(o), e.emit.columnOrder(o.order), e.emit.hiddenColumnKeys(
+          Object.entries(o.visibility).filter(([, s]) => !s).map(([s]) => s)
+        ), e.emit.columnWidths(o.widths), e.emit.columnPins(o.pins));
+      }
+      if (d) {
+        const i = Ue(d.rows.getSnapshot().groupBy), s = R(i);
+        s !== h && (h = s, e.emit.groupBy(i));
+        const S = d.state.get(), c = R(S);
+        M = c, c !== a && (a = c, e.emit.state(S));
+      }
+    }));
+  }, y = () => {
+    const o = e.gridRef.value?.api;
+    !o || e.props.sortModel === void 0 && e.props.filterModel === void 0 || o.rows.setSortAndFilterModel({
+      sortModel: e.props.sortModel ?? [],
+      filterModel: e.props.filterModel ?? null
+    });
+  }, P = () => {
+    const o = e.gridRef.value?.api;
+    !o || e.props.groupBy === void 0 || o.rows.setGroupBy(e.props.groupBy ?? null);
+  }, x = () => {
+    const o = e.gridRef.value?.api;
+    !o || e.props.aggregationModel === void 0 || o.rows.setAggregationModel(e.props.aggregationModel ?? null);
+  }, O = () => {
+    const o = e.gridRef.value?.api;
+    !o || e.props.pivotModel === void 0 || o.pivot.setModel(e.props.pivotModel ?? null);
+  }, G = () => {
+    const o = e.gridRef.value?.api;
+    if (!o || e.props.columnState === void 0 && e.props.columnOrder === void 0 && e.props.hiddenColumnKeys === void 0 && e.props.columnWidths === void 0 && e.props.columnPins === void 0)
+      return;
+    const d = R({
+      columnState: e.props.columnState,
+      columnOrder: e.props.columnOrder,
+      hiddenColumnKeys: e.props.hiddenColumnKeys,
+      columnWidths: e.props.columnWidths,
+      columnPins: e.props.columnPins
+    });
+    if (d !== f) {
+      if (e.props.columnState && !e.props.columnOrder && !e.props.hiddenColumnKeys && !e.props.columnWidths && !e.props.columnPins && R(e.props.columnState) === b) {
+        f = d;
+        return;
+      }
+      if (e.props.columnState) {
+        o.columns.setOrder(e.props.columnState.order);
+        for (const [i, s] of Object.entries(e.props.columnState.visibility))
+          o.columns.setVisibility(i, s);
+        for (const [i, s] of Object.entries(e.props.columnState.widths))
+          o.columns.setWidth(i, Q(s));
+        for (const [i, s] of Object.entries(e.props.columnState.pins))
+          o.columns.setPin(i, s);
+      }
+      if (e.props.columnOrder && o.columns.setOrder(e.props.columnOrder), e.props.hiddenColumnKeys) {
+        const i = new Set(e.props.hiddenColumnKeys), s = o.columns.getSnapshot();
+        for (const S of s.columns)
+          o.columns.setVisibility(S.key, !i.has(S.key));
+      }
+      if (e.props.columnWidths)
+        for (const [i, s] of Object.entries(e.props.columnWidths))
+          o.columns.setWidth(i, Q(s));
+      if (e.props.columnPins)
+        for (const [i, s] of Object.entries(e.props.columnPins))
+          o.columns.setPin(i, s);
+      f = d;
+    }
+  }, I = () => {
+    const o = e.gridRef.value?.api;
+    if (!o || e.props.state == null)
+      return;
+    const d = R(e.props.state);
+    if (d === u)
+      return;
+    if (d === M) {
+      u = d;
+      return;
+    }
+    const i = o.state.migrate(e.props.state, { strict: e.props.stateOptions?.strict });
+    i && (o.state.set(i, e.props.stateOptions ?? {}), u = d);
+  }, D = () => {
+    const o = e.gridRef.value?.api;
+    o && (o.view.setRowHeightMode(e.props.rowHeightMode), o.view.setBaseRowHeight(Math.max(24, Math.trunc(e.props.baseRowHeight))));
+  }, L = () => {
+    const o = e.gridRef.value;
+    o && (f = null, u = null, A(), t = o.rowModel.subscribe(() => {
+      v();
+    }), r = o.columnModel.subscribe(() => {
+      v();
+    }), I(), G(), y(), P(), x(), O(), D(), v(), e.emit.ready({ api: o.api }));
+  }, z = () => e.gridRef.value?.api.state.get() ?? null, V = (o, d) => e.gridRef.value?.api.state.migrate(o, d) ?? null, H = (o) => {
+    const d = e.gridRef.value?.api;
+    if (!d)
+      return !1;
+    f = R({
+      columnState: o,
+      columnOrder: null,
+      hiddenColumnKeys: null,
+      columnWidths: null,
+      columnPins: null
+    }), d.columns.setOrder(o.order);
+    for (const [i, s] of Object.entries(o.visibility))
+      d.columns.setVisibility(i, s);
+    for (const [i, s] of Object.entries(o.widths))
+      d.columns.setWidth(i, Q(s));
+    for (const [i, s] of Object.entries(o.pins))
+      d.columns.setPin(i, s);
+    return v(), !0;
+  }, E = (o, d) => {
+    const i = e.gridRef.value?.api;
+    if (!i)
+      return !1;
+    const s = i.state.migrate(o, { strict: d?.strict });
+    return s ? (i.state.set(s, d), u = R(o), v(), !0) : !1;
+  }, k = () => e.gridRef.value?.api.pivot.exportLayout() ?? null, N = () => e.gridRef.value?.api.pivot.exportInterop() ?? null, U = (o, d) => {
+    const i = e.gridRef.value?.api;
+    return i ? (i.pivot.importLayout(o, d), v(), !0) : !1;
+  }, j = () => {
+    e.gridRef.value?.api.rows.expandAllGroups(), v();
+  }, K = () => {
+    e.gridRef.value?.api.rows.collapseAllGroups(), v();
+  };
+  w(
+    () => e.gridRef.value,
+    () => {
+      L();
+    },
+    { immediate: !0 }
+  ), w(
+    () => e.props.columns,
+    () => {
+      f = null, u = null, I(), G(), v();
+    },
+    { deep: !0 }
+  ), w(
+    () => [e.props.state, e.props.stateOptions],
+    () => {
+      I(), G(), y(), P(), x(), O(), D(), v();
+    },
+    { deep: !0 }
+  ), w(
+    () => [
+      e.props.columnState,
+      e.props.columnOrder,
+      e.props.hiddenColumnKeys,
+      e.props.columnWidths,
+      e.props.columnPins
+    ],
+    () => {
+      G(), v();
+    },
+    { deep: !0 }
+  ), w(
+    () => [e.props.sortModel, e.props.filterModel],
+    () => {
+      y(), v();
+    },
+    { deep: !0 }
+  ), w(
+    () => e.props.groupBy,
+    () => {
+      P(), v();
+    },
+    { deep: !0 }
+  ), w(
+    () => e.props.aggregationModel,
+    () => {
+      x(), v();
+    },
+    { deep: !0 }
+  ), w(
+    () => e.props.pivotModel,
+    () => {
+      O(), v();
+    },
+    { deep: !0 }
+  ), w(
+    () => [e.props.rowHeightMode, e.props.baseRowHeight],
+    () => {
+      D(), v();
+    }
+  );
+  const F = () => {
+    A();
+  };
+  return Z(() => {
+    F();
+  }), {
+    emitSnapshotUpdates: v,
+    handleGridReady: L,
+    dispose: F,
+    getColumnState: C,
+    getState: z,
+    migrateState: V,
+    applyColumnState: H,
+    applyState: E,
+    exportPivotLayout: k,
+    exportPivotInterop: N,
+    importPivotLayout: U,
+    expandAllGroups: j,
+    collapseAllGroups: K
+  };
+}
+function Je() {
+  return {
+    name: "selection",
+    getRowSelectionSnapshot: () => null,
+    setRowSelectionSnapshot: () => {
+    },
+    clearRowSelection: () => {
+    },
+    getFocusedRow: () => null,
+    setFocusedRow: () => {
+    },
+    getSelectedRows: () => [],
+    isRowSelected: () => !1,
+    setRowSelected: () => {
+    },
+    selectRows: () => {
+    },
+    deselectRows: () => {
+    },
+    clearSelectedRows: () => {
+    }
+  };
+}
+function W(e, t) {
+  const r = t.map((n) => n?.[e]).filter((n) => typeof n == "function");
+  if (r.length !== 0)
+    return async (n) => {
+      for (const f of r)
+        await f(n);
+    };
+}
+function $e(e) {
+  const {
+    userSelectionService: t,
+    cellSelectionService: r,
+    rowSelectionService: n
+  } = e;
+  return {
+    name: "selection",
+    init: W("init", [t, r, n]),
+    start: W("start", [t, r, n]),
+    stop: W("stop", [t, r, n]),
+    dispose: W("dispose", [t, r, n]),
+    getSelectionSnapshot: r.getSelectionSnapshot,
+    setSelectionSnapshot: r.setSelectionSnapshot,
+    clearSelection: r.clearSelection,
+    getRowSelectionSnapshot: n.getRowSelectionSnapshot,
+    setRowSelectionSnapshot: n.setRowSelectionSnapshot,
+    clearRowSelection: n.clearRowSelection,
+    getFocusedRow: n.getFocusedRow,
+    setFocusedRow: n.setFocusedRow,
+    getSelectedRows: n.getSelectedRows,
+    isRowSelected: n.isRowSelected,
+    setRowSelected: n.setRowSelected,
+    selectRows: n.selectRows,
+    deselectRows: n.deselectRows,
+    clearSelectedRows: n.clearSelectedRows
+  };
+}
+const qe = ae({
+  name: "DataGrid",
+  inheritAttrs: !1,
+  props: {
+    rows: {
+      type: Array,
+      default: () => []
+    },
+    rowModel: {
+      type: Object,
+      default: void 0
+    },
+    clientRowModelOptions: {
+      type: Object,
+      default: void 0
+    },
+    computedFields: {
+      type: Array,
+      default: void 0
+    },
+    formulas: {
+      type: Array,
+      default: void 0
+    },
+    formulaFunctions: {
+      type: Object,
+      default: void 0
+    },
+    columns: {
+      type: Array,
+      default: () => []
+    },
+    theme: {
+      type: [String, Object],
+      default: void 0
+    },
+    aggregationModel: {
+      type: Object,
+      default: void 0
+    },
+    renderMode: {
+      type: String,
+      default: void 0
+    },
+    virtualization: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    pagination: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    columnMenu: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    cellMenu: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    rowIndexMenu: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    columnLayout: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    aggregations: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    advancedFilter: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    showRowIndex: {
+      type: Boolean,
+      default: !0
+    },
+    rowSelection: {
+      type: Boolean,
+      default: !0
+    },
+    pageSize: {
+      type: Number,
+      default: void 0
+    },
+    currentPage: {
+      type: Number,
+      default: void 0
+    },
+    plugins: {
+      type: Array,
+      default: () => []
+    },
+    services: {
+      type: Object,
+      default: void 0
+    },
+    startupOrder: {
+      type: Array,
+      default: void 0
+    },
+    autoStart: {
+      type: Boolean,
+      default: !0
+    },
+    sortModel: {
+      type: Array,
+      default: void 0
+    },
+    filterModel: {
+      type: Object,
+      default: void 0
+    },
+    groupBy: {
+      type: [String, Array, Object],
+      default: void 0
+    },
+    pivotModel: {
+      type: Object,
+      default: void 0
+    },
+    columnState: {
+      type: Object,
+      default: void 0
+    },
+    columnOrder: {
+      type: Array,
+      default: void 0
+    },
+    hiddenColumnKeys: {
+      type: Array,
+      default: void 0
+    },
+    columnWidths: {
+      type: Object,
+      default: void 0
+    },
+    columnPins: {
+      type: Object,
+      default: void 0
+    },
+    state: {
+      type: Object,
+      default: void 0
+    },
+    stateOptions: {
+      type: Object,
+      default: void 0
+    },
+    rowHeightMode: {
+      type: String,
+      default: "fixed"
+    },
+    baseRowHeight: {
+      type: Number,
+      default: 31
+    },
+    rowHover: {
+      type: Boolean,
+      default: !1
+    },
+    stripedRows: {
+      type: Boolean,
+      default: !1
+    },
+    isCellEditable: {
+      type: Function,
+      default: void 0
+    },
+    viewMode: {
+      type: String,
+      default: void 0
+    },
+    gantt: {
+      type: [Boolean, Object],
+      default: void 0
+    }
+  },
+  emits: [
+    "cell-change",
+    "selection-change",
+    "row-select",
+    "update:columnState",
+    "update:columnOrder",
+    "update:hiddenColumnKeys",
+    "update:columnWidths",
+    "update:columnPins",
+    "update:groupBy",
+    "update:viewMode",
+    "update:state",
+    "ready"
+  ],
+  setup(e, { attrs: t, slots: r, emit: n, expose: f }) {
+    const u = X(null), p = X("table"), a = g(() => Ke(e.renderMode, e.pagination)), h = g(() => Fe(
+      e.pagination,
+      a.value,
+      e.pageSize,
+      e.currentPage
+    )), b = g(() => he(e.columnMenu)), M = g(() => be(e.cellMenu)), A = g(() => Re(e.rowIndexMenu)), C = g(() => He(e.columnLayout)), v = g(() => Ee(e.aggregations)), y = g(() => Te(e.advancedFilter)), P = g(() => je(e.groupBy)), x = g(() => ke(e.virtualization, a.value)), O = g(() => Me({
+      columns: e.columns,
+      clientRowModelOptions: e.clientRowModelOptions,
+      computedFields: e.computedFields,
+      formulas: e.formulas,
+      formulaFunctions: e.formulaFunctions
+    })), G = g(() => Oe(e.columns)), I = {
+      get state() {
+        return e.state;
+      },
+      get stateOptions() {
+        return e.stateOptions;
+      },
+      get columnState() {
+        return e.columnState;
+      },
+      get columnOrder() {
+        return e.columnOrder;
+      },
+      get hiddenColumnKeys() {
+        return e.hiddenColumnKeys;
+      },
+      get columnWidths() {
+        return e.columnWidths;
+      },
+      get columnPins() {
+        return e.columnPins;
+      },
+      get sortModel() {
+        return e.sortModel;
+      },
+      get filterModel() {
+        return e.filterModel;
+      },
+      get groupBy() {
+        return P.value;
+      },
+      get aggregationModel() {
+        return e.aggregationModel;
+      },
+      get pivotModel() {
+        return e.pivotModel;
+      },
+      get rowHeightMode() {
+        return e.rowHeightMode;
+      },
+      get baseRowHeight() {
+        return e.baseRowHeight;
+      },
+      get columns() {
+        return e.columns;
+      }
+    }, D = g(() => e.pivotModel ? "pivot" : O.value && "initialTreeData" in O.value ? "tree" : "base"), L = g(() => u.value?.api.columns.getSnapshot().visibleColumns ?? []), z = g(() => u.value?.api.rows.getCount() ?? 0), V = {
+      mode: g(() => D.value),
+      resolveRuntime: () => u.value,
+      visibleColumns: L,
+      totalRows: z,
+      showRowSelection: g(() => e.rowSelection)
+    }, {
+      selectionSnapshot: H,
+      selectionAnchor: E,
+      syncSelectionSnapshotFromRuntime: k,
+      selectionService: N,
+      selectionAggregatesLabel: U
+    } = pe(V), {
+      rowSelectionSnapshot: j,
+      syncRowSelectionSnapshotFromRuntime: K,
+      reconcileRowSelectionFromRuntime: F,
+      selectionService: o
+    } = we({
+      resolveRuntime: () => u.value
+    }), d = g(() => e.rowSelection ? o : Je()), i = g(() => ({
+      ...e.services ?? {},
+      selection: $e({
+        userSelectionService: e.services?.selection,
+        cellSelectionService: N,
+        rowSelectionService: d.value
+      })
+    })), {
+      dataGridInstanceKey: s,
+      resolvedRowModel: S
+    } = Be({
+      rows: te(e, "rows"),
+      rowModel: te(e, "rowModel"),
+      clientRowModelOptions: O,
+      onOwnedRowModelRecreated: () => {
+        c.dispose();
+      }
+    }), c = _e({
+      gridRef: u,
+      props: I,
+      emit: {
+        columnState: (l) => n("update:columnState", l),
+        columnOrder: (l) => n("update:columnOrder", l),
+        hiddenColumnKeys: (l) => n("update:hiddenColumnKeys", l),
+        columnWidths: (l) => n("update:columnWidths", l),
+        columnPins: (l) => n("update:columnPins", l),
+        groupBy: (l) => n("update:groupBy", l),
+        state: (l) => n("update:state", l),
+        ready: (l) => n("ready", {
+          api: l.api,
+          rowModel: S.value
+        })
+      }
+    }), se = (l) => {
+      F(), n("cell-change", l), c.emitSnapshotUpdates();
+    }, de = (l) => {
+      n("selection-change", l);
+    };
+    w(
+      j,
+      (l) => {
+        n("row-select", l);
+      },
+      { deep: !0 }
+    ), w(
+      () => e.rowSelection,
+      (l) => {
+        if (l) {
+          K();
+          return;
+        }
+        o.clearRowSelection?.();
+      },
+      { immediate: !0 }
+    ), w(
+      () => e.viewMode,
+      (l) => {
+        p.value = l === "gantt" ? "gantt" : "table";
+      },
+      { immediate: !0 }
+    );
+    const ee = (l) => {
+      const m = l === "gantt" ? "gantt" : "table";
+      p.value = m, n("update:viewMode", m);
+    }, ce = () => {
+      const l = c.getState();
+      return l ? {
+        state: l,
+        viewMode: p.value
+      } : null;
+    }, me = (l, m) => ue(l, c.migrateState, m), fe = (l, m) => c.applyState(l.state, m) ? (l.viewMode && ee(l.viewMode), !0) : !1;
+    return Z(() => {
+      c.dispose();
+    }), f({
+      grid: u,
+      rowModel: S,
+      getApi: () => u.value?.api ?? null,
+      getRuntime: () => u.value?.runtime ?? null,
+      getCore: () => u.value?.core ?? null,
+      getColumnState: () => c.getColumnState(),
+      getColumnSnapshot: () => u.value?.api.columns.getSnapshot() ?? null,
+      getSelectionAggregatesLabel: () => U.value,
+      getSelectionSummary: () => u.value?.api.selection.summarize() ?? null,
+      getView: () => p.value,
+      setView: ee,
+      getSavedView: ce,
+      migrateSavedView: me,
+      applySavedView: fe,
+      applyColumnState: c.applyColumnState,
+      getState: c.getState,
+      migrateState: c.migrateState,
+      applyState: c.applyState,
+      exportPivotLayout: c.exportPivotLayout,
+      exportPivotInterop: c.exportPivotInterop,
+      importPivotLayout: c.importPivotLayout,
+      expandAllGroups: c.expandAllGroups,
+      collapseAllGroups: c.collapseAllGroups,
+      insertRowsAt: (l, m) => u.value?.api.rows.insertDataAt(l, m) ?? !1,
+      insertRowBefore: (l, m) => u.value?.api.rows.insertDataBefore(l, m) ?? !1,
+      insertRowAfter: (l, m) => u.value?.api.rows.insertDataAfter(l, m) ?? !1,
+      insertColumnsAt: (l, m) => u.value?.api.columns.insertAt(l, m) ?? !1,
+      insertColumnBefore: (l, m) => u.value?.api.columns.insertBefore(l, m) ?? !1,
+      insertColumnAfter: (l, m) => u.value?.api.columns.insertAfter(l, m) ?? !1
+    }), () => {
+      const l = {
+        mode: D.value,
+        rows: e.rows,
+        runtime: u.value?.runtime ?? null,
+        runtimeRowModel: u.value?.rowModel ?? null,
+        selectionSnapshot: H,
+        selectionAnchor: E,
+        rowSelectionSnapshot: j,
+        syncSelectionSnapshotFromRuntime: k,
+        syncRowSelectionSnapshotFromRuntime: K,
+        sortModel: e.sortModel,
+        filterModel: e.filterModel,
+        groupBy: P.value,
+        pivotModel: e.pivotModel,
+        renderMode: a.value,
+        virtualization: x.value,
+        columnMenu: b.value,
+        cellMenu: M.value,
+        rowIndexMenu: A.value,
+        columnLayout: C.value,
+        aggregations: v.value,
+        advancedFilter: y.value,
+        rowHeightMode: e.rowHeightMode,
+        baseRowHeight: e.baseRowHeight,
+        rowHover: e.rowHover,
+        stripedRows: e.stripedRows,
+        isCellEditable: e.isCellEditable,
+        showRowIndex: e.showRowIndex,
+        rowSelection: e.rowSelection,
+        viewMode: p.value,
+        gantt: e.gantt
+      };
+      return Y(
+        Ne,
+        {
+          ...t,
+          ref: u,
+          key: s.value,
+          rows: e.rows,
+          rowModel: S.value,
+          columns: G.value,
+          theme: e.theme,
+          renderMode: a.value,
+          pagination: h.value,
+          plugins: e.plugins,
+          services: i.value,
+          startupOrder: e.startupOrder,
+          autoStart: e.autoStart,
+          onCellChange: se,
+          onSelectionChange: de
+        },
+        r.default ? {
+          default: (m) => r.default?.({
+            ...m,
+            defaultRendererProps: {
+              ...l,
+              runtime: m.runtime,
+              runtimeRowModel: m.rowModel
+            }
+          })
+        } : {
+          default: (m) => Y(Ae, {
+            ...l,
+            runtime: m.runtime,
+            runtimeRowModel: m.rowModel
+          })
+        }
+      );
+    };
+  }
+}), rt = qe;
+export {
+  rt as DataGrid,
+  nt as clearDataGridSavedViewInStorage,
+  qe as default,
+  ue as migrateDataGridSavedView,
+  Ve as parseDataGridSavedView,
+  ot as readDataGridSavedViewFromStorage,
+  ze as serializeDataGridSavedView,
+  tt as writeDataGridSavedViewToStorage
+};