@oneflowui/ui 0.8.1 → 0.8.3

package/dist/components/table/DataTableDesktopFixedRegion.vue.d.ts

@@ -0,0 +1,56 @@
+import { CSSProperties, HTMLAttributes } from 'vue';
+import { TableColumn } from '../../types';
+declare const _default: <T extends {
+    id: string;
+} & Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onScroll?: ((event: Event) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onScroll"> & {
+        fixedWidth?: number;
+        showFixedShadow?: boolean;
+        regionClass?: HTMLAttributes["class"];
+        regionStyle?: CSSProperties;
+        columns?: TableColumn[];
+        allColumns?: TableColumn[];
+        selectable?: boolean;
+        showRowActions?: boolean;
+        useVirtual?: boolean;
+        totalHeight?: number;
+        offsetY?: number;
+        resolveRowId?: (item: T) => string;
+        setRegionRef?: (element: HTMLElement | null) => void;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        header?(_: {
+            branch: "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        body?(_: {
+            branch: "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+    };
+    emit: (evt: "scroll", event: Event) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/table/DataTableDesktopFixedRegion.vue.js

@@ -0,0 +1,7 @@
+import o from "./DataTableDesktopFixedRegion.vue2.js";
+/* empty css                                 */
+import a from "../../_virtual/_plugin-vue_export-helper.js";
+const r = /* @__PURE__ */ a(o, [["__scopeId", "data-v-c95a17a9"]]);
+export {
+  r as default
+};

package/dist/components/table/DataTableDesktopFixedRegion.vue2.js

@@ -0,0 +1,67 @@
+import { defineComponent as m, openBlock as h, createElementBlock as g, normalizeStyle as R, normalizeClass as w, renderSlot as a, normalizeProps as i, guardReactiveProps as s, createElementVNode as y } from "vue";
+const b = { class: "of-data-table-fixed-body" }, x = /* @__PURE__ */ m({
+  name: "DataTableDesktopFixedRegion",
+  __name: "DataTableDesktopFixedRegion",
+  props: {
+    fixedWidth: { default: 0 },
+    showFixedShadow: { type: Boolean, default: !1 },
+    regionClass: { type: [Boolean, null, String, Object, Array], default: void 0 },
+    regionStyle: { default: void 0 },
+    columns: { default: () => [] },
+    allColumns: { default: () => [] },
+    selectable: { type: Boolean, default: !0 },
+    showRowActions: { type: Boolean, default: !0 },
+    useVirtual: { type: Boolean, default: !1 },
+    totalHeight: { default: 0 },
+    offsetY: { default: 0 },
+    resolveRowId: { type: Function, default: void 0 },
+    setRegionRef: { type: Function, default: void 0 }
+  },
+  emits: ["scroll"],
+  setup(l, { emit: d }) {
+    const t = l, f = d;
+    function r(e) {
+      if (e instanceof HTMLElement)
+        return e;
+      if (e && "$el" in e) {
+        const o = e.$el;
+        return o instanceof HTMLElement ? o : null;
+      }
+      return null;
+    }
+    function u(e) {
+      var o;
+      (o = t.setRegionRef) == null || o.call(t, r(e));
+    }
+    function c(e) {
+      f("scroll", e);
+    }
+    function n() {
+      return {
+        branch: "fixed",
+        columns: t.columns,
+        allColumns: t.allColumns,
+        selectable: t.selectable,
+        showRowActions: t.showRowActions,
+        useVirtual: t.useVirtual,
+        totalHeight: t.totalHeight,
+        offsetY: t.offsetY,
+        resolveRowId: t.resolveRowId
+      };
+    }
+    return (e, o) => (h(), g("div", {
+      ref: u,
+      class: w(["of-data-table-fixed-region of-data-table-desktop-frame__fixed-region", [{ "of-fixed-shadow": l.showFixedShadow }, l.regionClass]]),
+      style: R([l.regionStyle, { width: `${l.fixedWidth}px` }]),
+      onScroll: c
+    }, [
+      a(e.$slots, "header", i(s(n())), void 0, !0),
+      y("div", b, [
+        a(e.$slots, "body", i(s(n())), void 0, !0)
+      ])
+    ], 38));
+  }
+});
+export {
+  x as default
+};

package/dist/components/table/DataTableDesktopFrame.vue.d.ts

@@ -0,0 +1,127 @@
+import { CSSProperties } from 'vue';
+import { ResolvedBulkActionItem } from '../../types/data-table';
+import { TableColumn } from '../../types';
+declare const _default: <T extends {
+    id: string;
+} & Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onScroll?: ((event: Event) => any) | undefined;
+        readonly "onSelection-action"?: ((action: ResolvedBulkActionItem) => any) | undefined;
+        readonly "onFixed-scroll"?: ((event: Event) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onScroll" | "onSelection-action" | "onFixed-scroll"> & {
+        hasFixedColumns?: boolean;
+        showSelectionBar?: boolean;
+        selectionCount?: number;
+        selectionItems?: ResolvedBulkActionItem[];
+        fixedWidth?: number;
+        showFixedShadow?: boolean;
+        columns?: TableColumn[];
+        fixedColumns?: TableColumn[];
+        scrollableColumns?: TableColumn[];
+        selectable?: boolean;
+        showRowActions?: boolean;
+        useVirtual?: boolean;
+        totalHeight?: number;
+        offsetY?: number;
+        shellStyle?: CSSProperties | (() => CSSProperties | undefined) | undefined;
+        bodyStyle?: CSSProperties | (() => CSSProperties | undefined) | undefined;
+        fixedRegionStyle?: CSSProperties | (() => CSSProperties | undefined) | undefined;
+        scrollRegionStyle?: CSSProperties | (() => CSSProperties | undefined) | undefined;
+        selectionBarStyle?: CSSProperties | (() => CSSProperties | undefined) | undefined;
+        resolveRowId?: (item: T) => string;
+        resolveBranchClass?: (branch: "standard" | "fixed") => string | string[] | Record<string, boolean>;
+        resolveBodyClass?: (branch: "standard" | "fixed") => string | string[] | Record<string, boolean>;
+        resolveFixedRegionClass?: () => string | string[] | Record<string, boolean>;
+        resolveScrollRegionClass?: () => string | string[] | Record<string, boolean>;
+        resolveSelectionBarClass?: () => string | string[] | Record<string, boolean>;
+        resolveBodyStyle?: () => CSSProperties | undefined;
+        resolveFixedRegionStyle?: () => CSSProperties | undefined;
+        resolveScrollRegionStyle?: () => CSSProperties | undefined;
+        resolveSelectionBarStyle?: () => CSSProperties | undefined;
+        onSelectionAction?: (action: ResolvedBulkActionItem) => void;
+        onFixedScroll?: (event: Event) => void;
+        onScroll?: (event: Event) => void;
+        setFixedRegionRef?: (element: HTMLElement | null) => void;
+        setScrollRegionRef?: (element: HTMLElement | null) => void;
+        setStandardScrollRef?: (element: HTMLElement | null) => void;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        'fixed-header'?(_: {
+            branch: "standard" | "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        'fixed-body'?(_: {
+            branch: "standard" | "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        'scroll-header'?(_: {
+            branch: "standard" | "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        'scroll-body'?(_: {
+            branch: "standard" | "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        'standard-header'?(_: {
+            branch: "standard" | "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        'standard-body'?(_: {
+            branch: "standard" | "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        footer?(_: {}): any;
+        overlay?(_: {}): any;
+    };
+    emit: ((evt: "scroll", event: Event) => void) & ((evt: "selection-action", action: ResolvedBulkActionItem) => void) & ((evt: "fixed-scroll", event: Event) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/table/DataTableDesktopFrame.vue.js

@@ -0,0 +1,7 @@
+import a from "./DataTableDesktopFrame.vue2.js";
+/* empty css                           */
+import o from "../../_virtual/_plugin-vue_export-helper.js";
+const m = /* @__PURE__ */ o(a, [["__scopeId", "data-v-637bbf7a"]]);
+export {
+  m as default
+};

package/dist/components/table/DataTableDesktopFrame.vue2.js

@@ -0,0 +1,196 @@
+import { defineComponent as H, computed as r, openBlock as u, createElementBlock as m, mergeProps as T, createBlock as w, normalizeStyle as g, normalizeClass as R, createCommentVNode as Y, createVNode as b, withCtx as i, renderSlot as n, normalizeProps as a, guardReactiveProps as d } from "vue";
+import j from "./DataTableDesktopFixedRegion.vue.js";
+import O from "./DataTableDesktopScrollRegion.vue.js";
+import P from "./DataTableDesktopStandardRegion.vue.js";
+import z from "./DataTableSelectionBar.vue.js";
+const J = /* @__PURE__ */ H({
+  name: "DataTableDesktopFrame",
+  inheritAttrs: !1,
+  __name: "DataTableDesktopFrame",
+  props: {
+    hasFixedColumns: { type: Boolean, default: !1 },
+    showSelectionBar: { type: Boolean, default: !0 },
+    selectionCount: { default: 0 },
+    selectionItems: { default: () => [] },
+    fixedWidth: { default: 0 },
+    showFixedShadow: { type: Boolean, default: !1 },
+    columns: { default: () => [] },
+    fixedColumns: { default: () => [] },
+    scrollableColumns: { default: () => [] },
+    selectable: { type: Boolean, default: !0 },
+    showRowActions: { type: Boolean, default: !0 },
+    useVirtual: { type: Boolean, default: !1 },
+    totalHeight: { default: 0 },
+    offsetY: { default: 0 },
+    shellStyle: { type: [Object, Function], default: void 0 },
+    bodyStyle: { type: [Object, Function], default: void 0 },
+    fixedRegionStyle: { type: [Object, Function], default: void 0 },
+    scrollRegionStyle: { type: [Object, Function], default: void 0 },
+    selectionBarStyle: { type: [Object, Function], default: void 0 },
+    resolveRowId: { type: Function, default: void 0 },
+    resolveBranchClass: { type: Function, default: void 0 },
+    resolveBodyClass: { type: Function, default: void 0 },
+    resolveFixedRegionClass: { type: Function, default: void 0 },
+    resolveScrollRegionClass: { type: Function, default: void 0 },
+    resolveSelectionBarClass: { type: Function, default: void 0 },
+    resolveBodyStyle: { type: Function, default: void 0 },
+    resolveFixedRegionStyle: { type: Function, default: void 0 },
+    resolveScrollRegionStyle: { type: Function, default: void 0 },
+    resolveSelectionBarStyle: { type: Function, default: void 0 },
+    onSelectionAction: { type: Function, default: void 0 },
+    onFixedScroll: { type: Function, default: void 0 },
+    onScroll: { type: Function, default: void 0 },
+    setFixedRegionRef: { type: Function, default: void 0 },
+    setScrollRegionRef: { type: Function, default: void 0 },
+    setStandardScrollRef: { type: Function, default: void 0 }
+  },
+  emits: ["selection-action", "scroll", "fixed-scroll"],
+  setup(t, { emit: F }) {
+    const e = t, f = F;
+    function c(l) {
+      return typeof l == "function" ? l() ?? {} : l ?? {};
+    }
+    const x = r(() => c(e.shellStyle)), v = r(() => c(e.resolveBodyStyle ?? e.bodyStyle)), C = r(
+      () => c(e.resolveFixedRegionStyle ?? e.fixedRegionStyle)
+    ), B = r(
+      () => c(e.resolveScrollRegionStyle ?? e.scrollRegionStyle)
+    ), k = r(
+      () => c(e.resolveSelectionBarStyle ?? e.selectionBarStyle)
+    );
+    function y(l) {
+      var o;
+      return (o = e.resolveBranchClass) == null ? void 0 : o.call(e, l);
+    }
+    function h(l) {
+      var o;
+      return (o = e.resolveBodyClass) == null ? void 0 : o.call(e, l);
+    }
+    function V() {
+      var l;
+      return (l = e.resolveFixedRegionClass) == null ? void 0 : l.call(e);
+    }
+    function A() {
+      var l;
+      return (l = e.resolveScrollRegionClass) == null ? void 0 : l.call(e);
+    }
+    function D() {
+      var l;
+      return (l = e.resolveSelectionBarClass) == null ? void 0 : l.call(e);
+    }
+    function $(l) {
+      var o;
+      f("selection-action", l), (o = e.onSelectionAction) == null || o.call(e, l);
+    }
+    function I(l) {
+      var o;
+      f("fixed-scroll", l), (o = e.onFixedScroll) == null || o.call(e, l);
+    }
+    function S(l) {
+      var o;
+      f("scroll", l), (o = e.onScroll) == null || o.call(e, l);
+    }
+    function s(l) {
+      return {
+        branch: l,
+        columns: l === "fixed" ? e.fixedColumns : e.scrollableColumns,
+        allColumns: e.columns,
+        selectable: e.selectable,
+        showRowActions: e.showRowActions,
+        useVirtual: e.useVirtual,
+        totalHeight: e.totalHeight,
+        offsetY: e.offsetY,
+        resolveRowId: e.resolveRowId
+      };
+    }
+    return (l, o) => (u(), m("section", T({ class: "of-data-table-desktop-frame" }, l.$attrs, { style: x.value }), [
+      t.showSelectionBar && t.selectionCount > 0 ? (u(), w(z, {
+        key: 0,
+        class: R(["of-data-table-desktop-frame__selection-bar", D()]),
+        style: g(k.value),
+        "selection-count": t.selectionCount,
+        items: t.selectionItems,
+        onAction: $
+      }, null, 8, ["class", "style", "selection-count", "items"])) : Y("", !0),
+      t.hasFixedColumns ? (u(), m("div", {
+        key: 1,
+        class: R(["of-data-table-body of-data-table-desktop-frame__body", [y("fixed"), h("fixed")]]),
+        style: g([v.value])
+      }, [
+        b(j, {
+          "fixed-width": t.fixedWidth,
+          "show-fixed-shadow": t.showFixedShadow,
+          "region-class": V(),
+          "region-style": C.value,
+          columns: t.fixedColumns,
+          "all-columns": t.columns,
+          selectable: t.selectable,
+          "show-row-actions": t.showRowActions,
+          "use-virtual": t.useVirtual,
+          "total-height": t.totalHeight,
+          "offset-y": t.offsetY,
+          "resolve-row-id": t.resolveRowId,
+          "set-region-ref": t.setFixedRegionRef,
+          onScroll: I
+        }, {
+          header: i(() => [
+            n(l.$slots, "fixed-header", a(d(s("fixed"))), void 0, !0)
+          ]),
+          body: i(() => [
+            n(l.$slots, "fixed-body", a(d(s("fixed"))), void 0, !0)
+          ]),
+          _: 3
+        }, 8, ["fixed-width", "show-fixed-shadow", "region-class", "region-style", "columns", "all-columns", "selectable", "show-row-actions", "use-virtual", "total-height", "offset-y", "resolve-row-id", "set-region-ref"]),
+        b(O, {
+          "fixed-width": t.fixedWidth,
+          "region-class": [y("fixed"), A()],
+          "region-style": B.value,
+          columns: t.scrollableColumns,
+          "all-columns": t.columns,
+          selectable: t.selectable,
+          "show-row-actions": t.showRowActions,
+          "use-virtual": t.useVirtual,
+          "total-height": t.totalHeight,
+          "offset-y": t.offsetY,
+          "resolve-row-id": t.resolveRowId,
+          "set-region-ref": t.setScrollRegionRef,
+          onScroll: S
+        }, {
+          header: i(() => [
+            n(l.$slots, "scroll-header", a(d(s("fixed"))), void 0, !0)
+          ]),
+          body: i(() => [
+            n(l.$slots, "scroll-body", a(d(s("fixed"))), void 0, !0)
+          ]),
+          _: 3
+        }, 8, ["fixed-width", "region-class", "region-style", "columns", "all-columns", "selectable", "show-row-actions", "use-virtual", "total-height", "offset-y", "resolve-row-id", "set-region-ref"])
+      ], 6)) : (u(), w(P, {
+        key: 2,
+        "container-class": [y("standard"), h("standard")],
+        "container-style": v.value,
+        columns: t.scrollableColumns,
+        "all-columns": t.columns,
+        selectable: t.selectable,
+        "show-row-actions": t.showRowActions,
+        "use-virtual": t.useVirtual,
+        "total-height": t.totalHeight,
+        "offset-y": t.offsetY,
+        "resolve-row-id": t.resolveRowId,
+        "set-container-ref": t.setStandardScrollRef,
+        onScroll: S
+      }, {
+        header: i(() => [
+          n(l.$slots, "standard-header", a(d(s("standard"))), void 0, !0)
+        ]),
+        body: i(() => [
+          n(l.$slots, "standard-body", a(d(s("standard"))), void 0, !0)
+        ]),
+        _: 3
+      }, 8, ["container-class", "container-style", "columns", "all-columns", "selectable", "show-row-actions", "use-virtual", "total-height", "offset-y", "resolve-row-id", "set-container-ref"])),
+      n(l.$slots, "footer", {}, void 0, !0),
+      n(l.$slots, "overlay", {}, void 0, !0)
+    ], 16));
+  }
+});
+export {
+  J as default
+};

package/dist/components/table/DataTableDesktopScrollRegion.vue.d.ts

@@ -0,0 +1,55 @@
+import { CSSProperties, HTMLAttributes } from 'vue';
+import { TableColumn } from '../../types';
+declare const _default: <T extends {
+    id: string;
+} & Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onScroll?: ((event: Event) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onScroll"> & {
+        fixedWidth?: number;
+        regionClass?: HTMLAttributes["class"];
+        regionStyle?: CSSProperties;
+        columns?: TableColumn[];
+        allColumns?: TableColumn[];
+        selectable?: boolean;
+        showRowActions?: boolean;
+        useVirtual?: boolean;
+        totalHeight?: number;
+        offsetY?: number;
+        resolveRowId?: (item: T) => string;
+        setRegionRef?: (element: HTMLElement | null) => void;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        header?(_: {
+            branch: "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        body?(_: {
+            branch: "fixed";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+    };
+    emit: (evt: "scroll", event: Event) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/table/DataTableDesktopScrollRegion.vue.js

@@ -0,0 +1,7 @@
+import o from "./DataTableDesktopScrollRegion.vue2.js";
+/* empty css                                  */
+import t from "../../_virtual/_plugin-vue_export-helper.js";
+const p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-5288db15"]]);
+export {
+  p as default
+};

package/dist/components/table/DataTableDesktopScrollRegion.vue2.js

@@ -0,0 +1,66 @@
+import { defineComponent as m, openBlock as g, createElementBlock as R, normalizeStyle as y, normalizeClass as b, renderSlot as a, normalizeProps as s, guardReactiveProps as i, createElementVNode as h } from "vue";
+const v = { class: "of-data-table-scroll-body" }, w = /* @__PURE__ */ m({
+  name: "DataTableDesktopScrollRegion",
+  __name: "DataTableDesktopScrollRegion",
+  props: {
+    fixedWidth: { default: 0 },
+    regionClass: { type: [Boolean, null, String, Object, Array], default: void 0 },
+    regionStyle: { default: void 0 },
+    columns: { default: () => [] },
+    allColumns: { default: () => [] },
+    selectable: { type: Boolean, default: !0 },
+    showRowActions: { type: Boolean, default: !0 },
+    useVirtual: { type: Boolean, default: !1 },
+    totalHeight: { default: 0 },
+    offsetY: { default: 0 },
+    resolveRowId: { type: Function, default: void 0 },
+    setRegionRef: { type: Function, default: void 0 }
+  },
+  emits: ["scroll"],
+  setup(o, { emit: r }) {
+    const t = o, d = r;
+    function f(e) {
+      if (e instanceof HTMLElement)
+        return e;
+      if (e && "$el" in e) {
+        const l = e.$el;
+        return l instanceof HTMLElement ? l : null;
+      }
+      return null;
+    }
+    function u(e) {
+      var l;
+      (l = t.setRegionRef) == null || l.call(t, f(e));
+    }
+    function c(e) {
+      d("scroll", e);
+    }
+    function n() {
+      return {
+        branch: "fixed",
+        columns: t.columns,
+        allColumns: t.allColumns,
+        selectable: t.selectable,
+        showRowActions: t.showRowActions,
+        useVirtual: t.useVirtual,
+        totalHeight: t.totalHeight,
+        offsetY: t.offsetY,
+        resolveRowId: t.resolveRowId
+      };
+    }
+    return (e, l) => (g(), R("div", {
+      ref: u,
+      class: b(["of-data-table-scroll-region of-data-table-desktop-frame__scroll-region", o.regionClass]),
+      style: y([o.regionStyle, { marginLeft: `${o.fixedWidth}px` }]),
+      onScroll: c
+    }, [
+      a(e.$slots, "header", s(i(n())), void 0, !0),
+      h("div", v, [
+        a(e.$slots, "body", s(i(n())), void 0, !0)
+      ])
+    ], 38));
+  }
+});
+export {
+  w as default
+};

package/dist/components/table/DataTableDesktopStandardRegion.vue.d.ts

@@ -0,0 +1,54 @@
+import { CSSProperties, HTMLAttributes } from 'vue';
+import { TableColumn } from '../../types';
+declare const _default: <T extends {
+    id: string;
+} & Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onScroll?: ((event: Event) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onScroll"> & {
+        containerClass?: HTMLAttributes["class"];
+        containerStyle?: CSSProperties;
+        columns?: TableColumn[];
+        allColumns?: TableColumn[];
+        selectable?: boolean;
+        showRowActions?: boolean;
+        useVirtual?: boolean;
+        totalHeight?: number;
+        offsetY?: number;
+        resolveRowId?: (item: T) => string;
+        setContainerRef?: (element: HTMLElement | null) => void;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        header?(_: {
+            branch: "standard";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+        body?(_: {
+            branch: "standard";
+            columns: TableColumn[];
+            allColumns: TableColumn[];
+            selectable: boolean;
+            showRowActions: boolean;
+            useVirtual: boolean;
+            totalHeight: number;
+            offsetY: number;
+            resolveRowId: ((item: T) => string) | undefined;
+        }): any;
+    };
+    emit: (evt: "scroll", event: Event) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/table/DataTableDesktopStandardRegion.vue.js

@@ -0,0 +1,7 @@
+import a from "./DataTableDesktopStandardRegion.vue2.js";
+/* empty css                                    */
+import o from "../../_virtual/_plugin-vue_export-helper.js";
+const p = /* @__PURE__ */ o(a, [["__scopeId", "data-v-c85a74a9"]]);
+export {
+  p as default
+};