@ynput/ayon-frontend-shared 0.3.56 → 0.4.1

package/dist/shared/src/containers/ProjectTreeTable/buildTreeTableColumns.es.js

@@ -1,5 +1,5 @@
-import { j as s } from "../../../../_virtual/jsx-runtime.es.js";
-import { sortingFns as k } from "@tanstack/react-table";
+import { j as d } from "../../../../_virtual/jsx-runtime.es.js";
+import { sortingFns as F } from "@tanstack/react-table";
 import "./widgets/CollapsedWidget.es.js";
 import "./widgets/DateWidget.es.js";
 import "./widgets/EnumWidget.es.js";
@@ -7,18 +7,19 @@ import "./widgets/EnumCellValue.es.js";
 import "./widgets/TextWidget.es.js";
 import "./widgets/MarkdownWidget.es.js";
 import "./widgets/BooleanWidget.es.js";
-import { CellWidget as b } from "./widgets/CellWidget.es.js";
-import { EntityNameWidget as w } from "./widgets/EntityNameWidget.es.js";
-import { GroupHeaderWidget as ii } from "./widgets/GroupHeaderWidget.es.js";
-import { ThumbnailWidget as ei } from "./widgets/ThumbnailWidget.es.js";
+import { CellWidget as x } from "./widgets/CellWidget.es.js";
+import { EntityNameWidget as ae } from "./widgets/EntityNameWidget.es.js";
+import { EntityWidget as W } from "./widgets/EntityWidget.es.js";
+import { GroupHeaderWidget as oe } from "./widgets/GroupHeaderWidget.es.js";
+import { ThumbnailWidget as se } from "./widgets/ThumbnailWidget.es.js";
 import "./widgets/LinksWidget.es.js";
 import "../../components/AddonLoadingScreen/AddonLoadingScreen.es.js";
 import "react";
 import "../../../../node_modules/match-sorter/dist/match-sorter.esm.es.js";
-import { Icon as W } from "@ynput/ayon-react-components";
+import { Icon as Z } from "@ynput/ayon-react-components";
 import "../../components/AccessSearchInput/AccessSearchInput.styled.es.js";
 import "../../components/AccessUser/AccessUser.es.js";
-import g from "clsx";
+import b from "clsx";
 import "../../components/AttributeEditor/AttributeEditor.es.js";
 import "../../components/AttributeEditor/attributeTypeMap.es.js";
 import "../../components/Badge/Badge.es.js";
@@ -131,10 +132,10 @@ import "../../../../_virtual/index.es.js";
 import "../../../../node_modules/refractor/lib/common.es.js";
 import "../../../../node_modules/refractor/lib/all.es.js";
 /* empty css                                                                              */
-import { upperFirst as ti } from "lodash";
-import { getEntityTypeIcon as G } from "../../util/getEntityTypeIcon.es.js";
+import { upperFirst as le } from "lodash";
+import { getEntityTypeIcon as q } from "../../util/getEntityTypeIcon.es.js";
 import "uuid";
-import { ROW_SELECTION_COLUMN_ID as U } from "./constants.es.js";
+import { ROW_SELECTION_COLUMN_ID as J } from "./constants.es.js";
 import "../../util/pubsub.es.js";
 import "../../components/DetailsPanelAttributes/DetailsPanelAttributesEditor.es.js";
 import "../../components/DetailsPanelDetails/DetailsPanelDetails.es.js";
@@ -204,18 +205,20 @@ import "../../components/EmptyPlaceholder/EmptyPlaceholder.es.js";
 import "../../components/EmptyPlaceholder/EmptyPlaceholderFlex.styled.es.js";
 import "../Feed/components/FeedSearchFilter.es.js";
 import "@tanstack/react-virtual";
-import { getCellId as F, getCellValue as _ } from "./utils/cellUtils.es.js";
-import { TableCellContent as K, LinkColumnHeader as ni } from "./ProjectTreeTable.styled.es.js";
-import { SelectionCell as ri } from "./components/SelectionCell.es.js";
-import oi from "./components/RowSelectionHeader.es.js";
-import { useCellEditing as ai } from "./context/CellEditingContext.es.js";
+import { TableCellContent as U, LinkColumnHeader as pe } from "./ProjectTreeTable.styled.es.js";
+import "./components/HeaderActionButton.es.js";
+import de from "./components/RowSelectionHeader.es.js";
+import { SelectionCell as me } from "./components/SelectionCell.es.js";
+import { useCellEditing as ue } from "./context/CellEditingContext.es.js";
 import "../../components/SearchFilter/filterDates.es.js";
 import "short-uuid";
-import { isEntityRestricted as M, READ_ONLY as li } from "./utils/restrictedEntity.es.js";
+import { normalizeColumnId as R, ENTITY_COLUMN_IDS as L } from "./utils/columnIds.es.js";
+import { getCellId as B, getCellValue as $ } from "./utils/cellUtils.es.js";
+import { isEntityRestricted as G, READ_ONLY as ge } from "./utils/restrictedEntity.es.js";
 import "./context/SelectionCellsContext.es.js";
 import "./context/ProjectTableQueriesContext.es.js";
-import { NEXT_PAGE_ID as h, parseGroupId as si } from "./hooks/useBuildGroupByTableData.es.js";
-import { useColumnSettingsContext as pi } from "./context/ColumnSettingsContext.es.js";
+import { NEXT_PAGE_ID as h, parseGroupId as ce } from "./hooks/useBuildGroupByTableData.es.js";
+import { useColumnSettingsContext as ye } from "./context/ColumnSettingsContext.es.js";
 import "./context/ProjectTableContextInstance.es.js";
 import "./context/ClipboardContext.es.js";
 import "./context/SelectedRowsContext.es.js";
@@ -229,9 +232,6 @@ import "../Slicer/hooks/useTableDataBySlice.es.js";
 import "react-redux";
 import "../NewEntity/context/NewEntityContextInstance.es.js";
 import "../NewEntity/components/NewEntityForm.es.js";
-import mi from "./widgets/LoadMoreWidget.es.js";
-import { getColumnDisplayConfig as di } from "./types/columnConfig.es.js";
-import "./components/HeaderActionButton.es.js";
 import "@dnd-kit/core";
 import "@dnd-kit/sortable";
 import "./components/TableFooterRow.es.js";
@@ -283,6 +283,7 @@ import "../../components/Powerpack/PowerpackDialog.styled.es.js";
 import "../../components/Powerpack/CTAButton.es.js";
 import "../../components/Powerpack/RequiredAddonVersion.es.js";
 import "../../components/ProjectTableSettings/ProjectTableSettings.es.js";
+import "../../components/ProjectTableSettings/ColumnsSettings.es.js";
 import "../../components/SizeSlider/SizeSlider.es.js";
 import "../../components/ReviewableCard/ReviewableCard.es.js";
 import "../../components/ReviewableProgressCard/ReviewableProgressCard.styled.es.js";
@@ -306,218 +307,327 @@ import "../../components/ReviewablesSelector/ReviewablesSelector.es.js";
 import "../../components/ColumnHeaderMenuUI.es.js";
 import "./widgets/EmptyWidget.es.js";
 import "./widgets/ErrorWidget.es.js";
-import { MetaWidget as ui } from "./widgets/MetaWidget.es.js";
-const gi = (a) => ["folder", "product"].includes(a), T = 50, x = (a) => (p, d, ...c) => p.original.isLoading !== d.original.isLoading ? p.original.isLoading ? 1 : -1 : a(p, d, ...c), Y = new Intl.Collator(void 0, { numeric: !0, sensitivity: "base" }), E = (a) => (p, d, ...c) => {
-  const I = a(p, d, ...c);
+import { MetaWidget as be } from "./widgets/MetaWidget.es.js";
+import fe from "./widgets/LoadMoreWidget.es.js";
+import { getColumnDisplayConfig as he } from "./types/columnConfig.es.js";
+const Te = (n) => ["folder", "product"].includes(n), T = 50, c = {
+  thumbnail: "Thumbnail",
+  status: "Status",
+  entityType: "Entity type",
+  subType: "Type",
+  assignees: "Assignees",
+  folder_entity: "Folder",
+  task_entity: "Task",
+  author: "Author",
+  version: "Version number",
+  version_entity: "Version",
+  product: "Product name",
+  productBaseType: "Base type",
+  taskType: "Task type",
+  folderType: "Folder type",
+  tags: "Tags",
+  createdAt: "Created at",
+  updatedAt: "Updated at",
+  subtasks: "Subtasks",
+  comments: "Latest comments"
+}, v = (n, p = []) => n === "subType" && p.some((l) => ["product", "version"].includes(l)) ? "Product type" : c[R(n)] || n, j = {
+  thumbnail: { enabled: !1, label: c.thumbnail },
+  name: { sortKey: "name", enabled: !0, label: "Name" },
+  entityType: { enabled: !1, label: c.entityType },
+  status: { sortKey: "status", sortDescFirst: !1, enabled: !0, label: c.status },
+  subType: {
+    sortKey: "taskType",
+    sortDescFirst: !0,
+    enabled: !0,
+    label: c.subType
+  },
+  assignees: {
+    sortKey: "assignees",
+    enabled: !0,
+    label: c.assignees,
+    scopes: ["task"]
+  },
+  folder_entity: {
+    sortKey: "folderName",
+    sortDescFirst: !1,
+    enabled: !0,
+    label: c.folder_entity
+  },
+  task_entity: {
+    sortKey: "taskName",
+    enabled: !1,
+    label: c.task_entity,
+    scopes: ["version", "product"]
+  },
+  author: {
+    sortKey: "author",
+    enabled: !0,
+    label: c.author,
+    scopes: ["version", "product"]
+  },
+  version: {
+    sortKey: "version",
+    sortDescFirst: !0,
+    enabled: !0,
+    label: c.version,
+    scopes: ["version", "product"]
+  },
+  version_entity: {
+    sortKey: "version",
+    enabled: !0,
+    label: c.version_entity,
+    scopes: ["version", "product"]
+  },
+  product: {
+    sortKey: "product",
+    enabled: !0,
+    label: c.product,
+    scopes: ["version", "product"]
+  },
+  productBaseType: {
+    sortKey: "productBaseType",
+    enabled: !0,
+    label: c.productBaseType,
+    scopes: ["version", "product"]
+  },
+  taskType: {
+    sortKey: "taskType",
+    sortDescFirst: !0,
+    enabled: !0,
+    label: c.taskType,
+    scopes: ["version", "product"]
+  },
+  folderType: {
+    sortKey: "folderType",
+    enabled: !0,
+    label: c.folderType,
+    scopes: ["version", "product"]
+  },
+  tags: { sortKey: "tags", enabled: !0, label: c.tags },
+  createdAt: { sortKey: "createdAt", enabled: !0, label: c.createdAt },
+  updatedAt: { sortKey: "updatedAt", enabled: !0, label: c.updatedAt },
+  subtasks: { enabled: !1, label: c.subtasks },
+  comments: { enabled: !1, label: c.comments }
+}, go = (n, p = []) => Object.entries(j).filter(
+  ([, l]) => l.enabled && (!l.scopes || !n || l.scopes.some((u) => n.includes(u)))
+).map(([l, u]) => ({
+  id: l,
+  label: p.find((I) => R(I.value) === l)?.label || v(l, n)
+})), ve = (n) => j[R(n)]?.enabled ?? !n.startsWith("link_"), co = (n, p = !0) => {
+  if (!n) return;
+  const l = R(n);
+  return l === "name" && !p ? "path" : j[l]?.sortKey ?? l;
+}, C = (n) => (p, l, ...u) => p.original.isLoading !== l.original.isLoading ? p.original.isLoading ? 1 : -1 : n(p, l, ...u), w = new Intl.Collator(void 0, { numeric: !0, sensitivity: "base" }), z = (n) => (p, l, ...u) => {
+  const I = n(p, l, ...u);
   if (I !== 0) return I;
-  const R = p.original.label || p.original.name || "", L = d.original.label || d.original.name || "";
-  return Y.compare(R, L);
-}, j = (a, p) => {
-  const d = a.original.label || a.original.path || a.original.name || "", c = p.original.label || p.original.path || p.original.name || "";
-  return Y.compare(d, c);
-}, X = (a, p, d) => {
-  const c = _(a.original, d), I = _(p.original, d), R = Array.isArray(c) ? c.length : c ? String(c).length : 0, L = Array.isArray(I) ? I.length : I ? String(I).length : 0;
-  return R - L;
-}, V = (a, p, d, c) => {
-  const I = _(a.original, d), R = _(p.original, d);
-  if (c && c.enum) {
-    const L = c.enum.findIndex((N) => N.value === I), A = c.enum.findIndex((N) => N.value === R);
-    return L - A;
-  } else return c?.type === "datetime" ? k.datetime(a, p, d) : c?.type === "boolean" ? (I === !0 ? 1 : 0) - (R === !0 ? 1 : 0) : k.alphanumeric(a, p, d);
-}, ci = (a, p) => `${a.linkType.charAt(0).toUpperCase() + a.linkType.slice(1)} (${p})`, Z = (a, p) => `${a.name.replaceAll("_", "").replaceAll("-", "").replaceAll("|", "_")}_${p}`, yi = (a, p) => `link_${Z(a, p)}`, na = ({
-  scopes: a,
+  const E = p.original.label || p.original.name || "", O = l.original.label || l.original.name || "";
+  return w.compare(E, O);
+}, _ = (n, p) => {
+  const l = n.original.label || n.original.path || n.original.name || "", u = p.original.label || p.original.path || p.original.name || "";
+  return w.compare(l, u);
+}, Q = (n, p, l) => {
+  const u = $(n.original, l), I = $(p.original, l), E = Array.isArray(u) ? u.length : u ? String(u).length : 0, O = Array.isArray(I) ? I.length : I ? String(I).length : 0;
+  return E - O;
+}, Y = (n, p, l, u) => {
+  const I = $(n.original, l), E = $(p.original, l);
+  if (u && u.enum) {
+    const O = u.enum.findIndex((K) => K.value === I), H = u.enum.findIndex((K) => K.value === E);
+    return O - H;
+  } else return u?.type === "datetime" ? F.datetime(n, p, l) : u?.type === "boolean" ? (I === !0 ? 1 : 0) - (E === !0 ? 1 : 0) : F.alphanumeric(n, p, l);
+}, Ie = (n, p) => `${n.linkType.charAt(0).toUpperCase() + n.linkType.slice(1)} (${p})`, ee = (n, p) => `${n.name.replaceAll("_", "").replaceAll("-", "").replaceAll("|", "_")}_${p}`, Se = (n, p) => `link_${ee(n, p)}`, yo = ({
+  scopes: n,
   attribs: p,
-  links: d = [],
-  includeLinks: c = !0,
+  links: l = [],
+  includeLinks: u = !0,
   showHierarchy: I,
-  isFlatFolderView: R,
-  options: L,
-  excluded: A,
-  excludedSorting: N,
-  extraColumns: $,
-  groupBy: D,
-  nameLabel: q = "Entity"
+  isFlatFolderView: E,
+  options: O,
+  excluded: H,
+  excludedSorting: K,
+  extraColumns: X,
+  groupBy: P,
+  nameLabel: ie = "Entity"
 }) => {
-  const y = [], u = (i) => !A?.includes(i), v = (i) => !N?.includes(i);
-  u(U) && y.push({
-    id: U,
+  const y = [], g = (e) => !H?.some((i) => R(i) === R(e)), S = (e) => ve(e) && !K?.some((i) => R(i) === R(e));
+  g(J) && y.push({
+    id: J,
     enableResizing: !1,
     enableSorting: !1,
     enablePinning: !1,
     enableHiding: !1,
-    header: () => /* @__PURE__ */ s.jsx(oi, {}),
-    cell: ({ row: i }) => i.original.entityType === "group" || i.original.metaType ? null : /* @__PURE__ */ s.jsx(ri, {}),
+    header: () => /* @__PURE__ */ d.jsx(de, {}),
+    cell: ({ row: e }) => e.original.entityType === "group" || e.original.metaType ? null : /* @__PURE__ */ d.jsx(me, {}),
     size: 20
-  }), u("thumbnail") && y.push({
+  }), g("thumbnail") && y.push({
     id: "thumbnail",
-    header: "Thumbnail",
+    header: v("thumbnail"),
     size: 63,
     minSize: 24,
     enableResizing: !0,
     enableSorting: !1,
-    cell: ({ row: i, column: e, table: t }) => {
-      if (i.original.entityType === "group" || i.original.metaType) return null;
-      const n = t.options.meta;
-      if (!n) return null;
-      const o = F(i.id, e.id);
-      let r = {
-        entityId: i.original.entityId || i.id,
-        entityType: i.original.entityType,
-        thumbnailHash: i.original.thumbnailHash
+    cell: ({ row: e, column: i, table: t }) => {
+      if (e.original.entityType === "group" || e.original.metaType) return null;
+      const r = t.options.meta;
+      if (!r) return null;
+      const a = B(e.id, i.id);
+      let o = {
+        entityId: e.original.entityId || e.id,
+        entityType: e.original.entityType,
+        thumbnailHash: e.original.thumbnailHash
       };
-      return i.original.thumbnail && (r = i.original.thumbnail), /* @__PURE__ */ s.jsx(
-        ei,
+      return e.original.thumbnail && (o = e.original.thumbnail), /* @__PURE__ */ d.jsx(
+        se,
         {
-          id: o,
-          entityId: r.entityId,
-          entityType: r.entityType,
-          thumbnailHash: r.thumbnailHash,
-          icon: i.original.icon,
-          projectName: n?.projectName,
-          className: g("thumbnail", {
-            loading: i.original.isLoading
+          id: a,
+          entityId: o.entityId,
+          entityType: o.entityType,
+          thumbnailHash: o.thumbnailHash,
+          icon: e.original.icon,
+          projectName: r?.projectName,
+          className: b("thumbnail", {
+            loading: e.original.isLoading
           }),
-          isPlayable: i.original.hasReviewables
+          isPlayable: e.original.hasReviewables
         }
       );
     }
-  }), u("name") && y.push({
+  }), g("name") && y.push({
     id: "name",
     accessorKey: "name",
-    header: q,
+    header: ie,
     minSize: T,
-    sortingFn: x(j),
-    enableSorting: D && D.id !== "folder" ? !1 : v("name"),
+    sortingFn: C(_),
+    enableSorting: P && P.id !== "folder" ? !1 : S("name"),
     enableResizing: !0,
     enablePinning: !0,
-    enableHiding: !(D && D.id !== "folder"),
-    cell: ({ row: i, column: e, table: t }) => {
-      const { value: n, id: o, type: r } = f(i, e.id), l = t.options.meta, { isEditing: m } = ai(), { rowHeight: S = 40 } = pi(), C = F(i.id, e.id);
-      if (i.original.metaType)
-        return /* @__PURE__ */ s.jsx(
-          K,
+    enableHiding: !(P && P.id !== "folder"),
+    cell: ({ row: e, column: i, table: t }) => {
+      const { value: r, id: a, type: o } = f(e, i.id), s = t.options.meta, { isEditing: m } = ue(), { rowHeight: k = 40 } = ye(), N = B(e.id, i.id);
+      if (e.original.metaType)
+        return /* @__PURE__ */ d.jsx(
+          U,
           {
-            id: C,
-            className: g("large", "readonly", i.original.entityType),
+            id: N,
+            className: b("large", "readonly", e.original.entityType),
             style: {
-              paddingLeft: `calc(${i.depth * 1}rem + 8px)`,
+              paddingLeft: `calc(${e.depth * 1}rem + 8px)`,
               pointerEvents: "none"
             },
             tabIndex: 0,
-            children: /* @__PURE__ */ s.jsx(ui, { metaType: i.original.metaType, label: i.original.label })
+            children: /* @__PURE__ */ d.jsx(be, { metaType: e.original.metaType, label: e.original.label })
           }
         );
-      if (i.original.entityType === h && i.original.group)
-        return /* @__PURE__ */ s.jsx(
-          mi,
+      if (e.original.entityType === h && e.original.group)
+        return /* @__PURE__ */ d.jsx(
+          fe,
           {
-            id: i.original.group.value,
-            onLoadMore: (P) => l?.loadMoreRows?.(P)
+            id: e.original.group.value,
+            onLoadMore: (V) => s?.loadMoreRows?.(V)
           }
         );
-      const O = i.getCanExpand() && !!i.originalSubRows && (gi(i.original.entityType) || !!i.original.group);
-      return /* @__PURE__ */ s.jsxs(
-        K,
+      const A = e.getCanExpand() && !!e.originalSubRows && (Te(e.original.entityType) || !!e.original.group);
+      return /* @__PURE__ */ d.jsxs(
+        U,
         {
-          id: C,
-          className: g("large", i.original.entityType, {
-            loading: i.original.isLoading,
+          id: N,
+          className: b("large", e.original.entityType, {
+            loading: e.original.isLoading,
             hierarchy: I
           }),
           style: {
-            paddingLeft: `calc(${i.depth * 1}rem + ${O || !i.getCanExpand() ? 0 : 32}px + 8px)`
+            paddingLeft: `calc(${e.depth * 1}rem + ${A || !e.getCanExpand() ? 0 : 32}px + 8px)`
           },
           tabIndex: 0,
           children: [
-            i.original.group ? /* @__PURE__ */ s.jsx(
-              ii,
+            e.original.group ? /* @__PURE__ */ d.jsx(
+              oe,
               {
-                id: i.id,
-                label: i.original.group.label,
-                name: i.original.name,
-                icon: i.original.group.icon,
-                img: i.original.group.img,
-                color: i.original.group.color,
-                count: i.original.group.count,
-                percentage: i.original.group.percentage,
-                isExpanded: i.getIsExpanded(),
-                isEmpty: i.original.group.count === 0,
-                toggleExpanded: i.getToggleExpandedHandler()
+                id: e.id,
+                label: e.original.group.label,
+                name: e.original.name,
+                icon: e.original.group.icon,
+                img: e.original.group.img,
+                color: e.original.group.color,
+                count: e.original.group.count,
+                percentage: e.original.group.percentage,
+                isExpanded: e.getIsExpanded(),
+                isEmpty: e.original.group.count === 0,
+                toggleExpanded: e.getToggleExpandedHandler()
               }
-            ) : /* @__PURE__ */ s.jsx(
-              w,
+            ) : /* @__PURE__ */ d.jsx(
+              ae,
               {
-                id: i.id,
-                label: i.original.label,
-                name: i.original.name,
-                path: !I && !R ? "/" + i.original.parents?.join("/") : void 0,
-                entityType: i.original.entityType,
-                subType: i.original.subType,
-                isExpandable: O,
-                isExpanded: i.getIsExpanded(),
-                toggleExpandAll: () => l?.toggleExpandAll?.([i.id]),
-                toggleExpanded: i.getToggleExpandedHandler(),
-                rowHeight: S,
-                columnDisplayConfig: di(l?.columnsConfig, "name")
+                id: e.id,
+                label: e.original.label,
+                name: e.original.name,
+                path: !I && !E ? "/" + e.original.parents?.join("/") : void 0,
+                entityType: e.original.entityType,
+                subType: e.original.subType,
+                isExpandable: A,
+                isExpanded: e.getIsExpanded(),
+                toggleExpandAll: () => s?.toggleExpandAll?.([e.id]),
+                toggleExpanded: e.getToggleExpandedHandler(),
+                rowHeight: k,
+                columnDisplayConfig: he(s?.columnsConfig, "name")
               }
             ),
-            m(C) && /* @__PURE__ */ s.jsx(
-              b,
+            m(N) && /* @__PURE__ */ d.jsx(
+              x,
               {
-                rowId: o,
-                className: g("name", { loading: i.original.isLoading }),
-                columnId: e.id,
-                value: n,
+                rowId: a,
+                className: b("name", { loading: e.original.isLoading }),
+                columnId: i.id,
+                value: r,
                 valueData: {
-                  name: i.original.name,
-                  label: i.original.label,
-                  meta: l,
-                  entityRowId: o,
-                  columnId: e.id,
-                  hasVersions: !!i.original.hasVersions
+                  name: e.original.name,
+                  label: e.original.label,
+                  meta: s,
+                  entityRowId: a,
+                  columnId: i.id,
+                  hasVersions: !!e.original.hasVersions
                 },
-                entityType: r,
+                entityType: o,
                 attributeData: { type: "name" },
-                isCollapsed: !!i.original.childOnlyMatch,
-                isReadOnly: l?.readOnly?.includes(e.id)
+                isCollapsed: !!e.original.childOnlyMatch,
+                isReadOnly: s?.readOnly?.includes(i.id)
               }
             )
           ]
         }
       );
     }
-  }), u("status") && y.push({
+  }), g("status") && y.push({
     id: "status",
     accessorKey: "status",
     minSize: T,
-    header: "Status",
-    sortingFn: x(
-      E(
-        (i, e, t) => V(i, e, t, { enum: L.status, type: "string" })
+    header: v("status"),
+    sortingFn: C(
+      z(
+        (e, i, t) => Y(e, i, t, { enum: O.status, type: "string" })
       )
     ),
-    sortDescFirst: !0,
-    enableSorting: v("status"),
+    sortDescFirst: j.status.sortDescFirst,
+    enableSorting: S("status"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    cell: ({ row: i, column: e, table: t }) => {
-      const { value: n, id: o, type: r } = f(i, e.id), l = t.options.meta;
-      return ["group", h].includes(r) || i.original.metaType ? null : /* @__PURE__ */ s.jsx(
-        b,
+    cell: ({ row: e, column: i, table: t }) => {
+      const { value: r, id: a, type: o } = f(e, i.id), s = t.options.meta;
+      return ["group", h].includes(o) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: o,
-          className: g("status", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: n,
+          rowId: a,
+          className: b("status", { loading: e.original.isLoading }),
+          columnId: i.id,
+          value: r,
           attributeData: { type: "string" },
-          options: l?.options?.status.filter((m) => m.scope?.includes(r)),
-          isCollapsed: !!i.original.childOnlyMatch,
-          onChange: (m) => l?.updateEntities?.(
-            { field: e.id, value: m, type: r, rowId: o },
-            { selection: l?.selection }
+          options: s?.options?.status.filter((m) => m.scope?.includes(o)),
+          isCollapsed: !!e.original.childOnlyMatch,
+          onChange: (m) => s?.updateEntities?.(
+            { field: i.id, value: m, type: o, rowId: a },
+            { selection: s?.selection }
           ),
-          isReadOnly: l?.readOnly?.includes(e.id) || M(r),
+          isReadOnly: s?.readOnly?.includes(i.id) || G(o),
           pt: {
             enum: {
               pt: {
@@ -536,71 +646,72 @@ const gi = (a) => ["folder", "product"].includes(a), T = 50, x = (a) => (p, d, .
         }
       );
     }
-  }), u("entityType") && y.push({
+  }), g("entityType") && y.push({
     id: "entityType",
     accessorKey: "entityType",
-    header: "Entity Type",
+    header: v("entityType"),
     minSize: 20,
     enableSorting: !1,
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(E(k.alphanumeric)),
-    cell: ({ row: i, column: e, table: t }) => {
-      const { value: n, id: o, type: r } = f(i, e.id);
-      if (["group", h].includes(r) || i.original.metaType) return null;
-      const l = F(i.id, e.id);
-      return /* @__PURE__ */ s.jsxs(
-        K,
+    sortingFn: C(z(F.alphanumeric)),
+    cell: ({ row: e, column: i, table: t }) => {
+      const { value: r, id: a, type: o } = f(e, i.id);
+      if (["group", h].includes(o) || e.original.metaType) return null;
+      const s = B(e.id, i.id);
+      return /* @__PURE__ */ d.jsxs(
+        U,
         {
-          id: l,
-          className: g("entityType", li, r, { loading: i.original.isLoading }),
+          id: s,
+          className: b("entityType", ge, o, { loading: e.original.isLoading }),
           tabIndex: 0,
           children: [
-            /* @__PURE__ */ s.jsx(W, { icon: G(r) }),
+            /* @__PURE__ */ d.jsx(Z, { icon: q(o) }),
             " ",
-            ti(n)
+            le(r)
           ]
         }
       );
     }
-  }), u("subType") && y.push({
+  }), g("subType") && y.push({
     id: "subType",
     accessorKey: "subType",
-    header: a.includes("product") || a.includes("version") ? "Product type" : "Type",
+    header: v("subType", n),
     minSize: T,
-    enableSorting: v("subType"),
+    enableSorting: S("subType"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(
-      E(
-        (i, e, t) => V(i, e, t, {
-          enum: [...L.folderType, ...L.taskType],
+    sortDescFirst: j.taskType.sortDescFirst,
+    sortingFn: C(
+      z(
+        (e, i, t) => Y(e, i, t, {
+          enum: [...O.folderType, ...O.taskType],
           type: "string"
         })
       )
     ),
-    cell: ({ row: i, column: e, table: t }) => {
-      const { value: n, id: o, type: r } = f(i, e.id);
-      if (["group", h].includes(r) || i.original.metaType) return null;
-      const l = r === "folder" ? "folderType" : "taskType", m = t.options.meta, S = r === "folder" && i.original.hasVersions;
-      return /* @__PURE__ */ s.jsx(
-        b,
+    cell: ({ row: e, column: i, table: t }) => {
+      const { value: r, id: a, type: o } = f(e, i.id);
+      if (["group", h].includes(o) || e.original.metaType) return null;
+      const s = o === "folder" ? "folderType" : "taskType", m = t.options.meta, k = o === "folder" && e.original.hasVersions;
+      return /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: o,
-          className: g("subType", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: n,
+          rowId: a,
+          className: b("subType", { loading: e.original.isLoading }),
+          columnId: i.id,
+          value: r,
           attributeData: { type: "string" },
-          options: r === "folder" ? m?.options?.folderType : r === "task" ? m?.options?.taskType : r === "product" || r === "version" ? m?.options?.productType : [],
-          isCollapsed: !!i.original.childOnlyMatch,
-          onChange: (C) => m?.updateEntities?.(
-            { field: l, value: C, type: r, rowId: i.id },
+          options: o === "folder" ? m?.options?.folderType : o === "task" ? m?.options?.taskType : o === "product" || o === "version" ? m?.options?.productType : [],
+          isCollapsed: !!e.original.childOnlyMatch,
+          onChange: (N) => m?.updateEntities?.(
+            { field: s, value: N, type: o, rowId: e.id },
             { selection: m?.selection }
           ),
-          isReadOnly: m?.readOnly?.includes(e.id) || m?.readOnly?.includes(l) || S,
-          tooltip: S ? "Folder type cannot be edited when versions exist within the folder" : void 0,
+          isReadOnly: m?.readOnly?.includes(i.id) || m?.readOnly?.includes(s) || k,
+          tooltip: k ? "Folder type cannot be edited when versions exist within the folder" : void 0,
           pt: {
             enum: {
               pt: {
@@ -613,45 +724,45 @@ const gi = (a) => ["folder", "product"].includes(a), T = 50, x = (a) => (p, d, .
         }
       );
     }
-  }), u("assignees") && y.push({
+  }), g("assignees") && y.push({
     id: "assignees",
     accessorKey: "assignees",
-    header: "Assignees",
+    header: v("assignees"),
     minSize: T,
-    enableSorting: v("assignees"),
+    enableSorting: S("assignees"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(E(X)),
-    cell: ({ row: i, column: e, table: t }) => {
-      const n = t.options.meta, { value: o, id: r, type: l } = f(i, e.id);
-      return ["group", h].includes(l) || i.original.metaType ? null : l === "folder" ? /* @__PURE__ */ s.jsx(
-        b,
+    sortingFn: C(z(Q)),
+    cell: ({ row: e, column: i, table: t }) => {
+      const r = t.options.meta, { value: a, id: o, type: s } = f(e, i.id);
+      return ["group", h].includes(s) || e.original.metaType ? null : s === "folder" ? /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: r,
-          className: g("assignees", { loading: i.original.isLoading }),
-          columnId: e.id,
+          rowId: o,
+          className: b("assignees", { loading: e.original.isLoading }),
+          columnId: i.id,
           value: "",
           isPlaceholder: !0
         }
-      ) : /* @__PURE__ */ s.jsx(
-        b,
+      ) : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: r,
-          className: g("assignees", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: o,
+          rowId: o,
+          className: b("assignees", { loading: e.original.isLoading }),
+          columnId: i.id,
+          value: a,
           attributeData: { type: "list_of_strings" },
-          options: n?.options?.assignee,
-          isCollapsed: !!i.original.childOnlyMatch,
-          onChange: (m) => n?.updateEntities?.(
-            { field: e.id, value: m, type: l, rowId: i.id },
-            { selection: n?.selection }
+          options: r?.options?.assignee,
+          isCollapsed: !!e.original.childOnlyMatch,
+          onChange: (m) => r?.updateEntities?.(
+            { field: i.id, value: m, type: s, rowId: e.id },
+            { selection: r?.selection }
           ),
-          isReadOnly: n?.readOnly?.includes(e.id) || M(l),
+          isReadOnly: r?.readOnly?.includes(i.id) || G(s),
           pt: {
             enum: {
-              multiSelectClose: o?.length === 0,
+              multiSelectClose: a?.length === 0,
               // close the dropdown on first assignment
               search: !0,
               // enable search at all times
@@ -661,301 +772,356 @@ const gi = (a) => ["folder", "product"].includes(a), T = 50, x = (a) => (p, d, .
         }
       );
     }
-  }), u("folder") && y.push({
-    id: "folder",
+  }), g(L.folder) && y.push({
+    id: L.folder,
     accessorKey: "folder",
-    header: "Folder name",
+    header: v(L.folder),
     minSize: T,
-    sortingFn: x(j),
-    enableSorting: v("folderName"),
+    sortDescFirst: j.folder_entity.sortDescFirst,
+    sortingFn: C(_),
+    enableSorting: S(L.folder),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    cell: ({ row: i, column: e, table: t }) => {
-      const { value: n, id: o, type: r } = f(i, e.id);
-      return ["group", h].includes(r) || i.original.metaType ? null : /* @__PURE__ */ s.jsx(
-        b,
+    cell: ({ row: e, column: i, table: t }) => {
+      const { value: r, id: a, type: o } = f(e, "folder");
+      return ["group", h].includes(o) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        W,
         {
-          rowId: o,
-          className: g("folder", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: n,
-          attributeData: { type: "string" },
-          isReadOnly: !0
+          rowId: a,
+          className: "folder",
+          columnId: i.id,
+          value: r,
+          entityId: e.original.folderId,
+          entityType: "folder",
+          subType: e.original.folderType,
+          isLoading: e.original.isLoading
         }
       );
     }
-  }), u("author") && ["version", "product"].some((i) => a.includes(i)) && y.push({
+  }), g(L.task) && ["version", "product"].some((e) => n.includes(e)) && y.push({
+    id: L.task,
+    accessorKey: "taskLabel",
+    header: v(L.task),
+    minSize: T,
+    enableSorting: S(L.task),
+    enableResizing: !0,
+    enablePinning: !0,
+    enableHiding: !0,
+    sortingFn: C(_),
+    cell: ({ row: e, column: i }) => {
+      const { value: t, id: r, type: a } = f(e, "taskLabel");
+      return ["group", h].includes(a) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        W,
+        {
+          rowId: r,
+          className: "task_entity",
+          columnId: i.id,
+          value: t,
+          entityId: e.original.taskId,
+          entityType: "task",
+          subType: e.original.taskType,
+          isLoading: e.original.isLoading
+        }
+      );
+    }
+  }), g("author") && ["version", "product"].some((e) => n.includes(e)) && y.push({
     id: "author",
     accessorKey: "author",
-    header: "Author",
+    header: v("author"),
     minSize: T,
-    enableSorting: v("author"),
+    enableSorting: S("author"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(j),
-    cell: ({ row: i, column: e, table: t }) => {
-      const n = t.options.meta, { value: o, id: r, type: l } = f(i, e.id);
-      return ["group", h].includes(l) || i.original.metaType ? null : /* @__PURE__ */ s.jsx(
-        b,
+    sortingFn: C(_),
+    cell: ({ row: e, column: i, table: t }) => {
+      const r = t.options.meta, { value: a, id: o, type: s } = f(e, i.id);
+      return ["group", h].includes(s) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: r,
-          className: g("author", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: [o],
+          rowId: o,
+          className: b("author", { loading: e.original.isLoading }),
+          columnId: i.id,
+          value: [a],
           attributeData: { type: "list_of_strings" },
-          options: n?.options?.assignee,
+          options: r?.options?.assignee,
           isReadOnly: !0,
-          isInherited: l === "product"
+          isInherited: s === "product"
+        }
+      );
+    }
+  }), g(L.version) && ["version", "product"].some((e) => n.includes(e)) && y.push({
+    id: L.version,
+    accessorKey: "versionName",
+    header: v(L.version),
+    minSize: T,
+    enableSorting: S(L.version),
+    enableResizing: !0,
+    enablePinning: !0,
+    enableHiding: !0,
+    sortingFn: C(_),
+    cell: ({ row: e, column: i }) => {
+      const { value: t, id: r, type: a } = f(e, "versionName");
+      if (["group", h].includes(a) || e.original.metaType) return null;
+      let o = e.original.versionName || t;
+      return e.original.entityType === "product" && (o = `${e.original.versionName} (${e.original.versionsCount || 0} versions)`), /* @__PURE__ */ d.jsx(
+        W,
+        {
+          rowId: r,
+          className: "version-entity",
+          columnId: i.id,
+          value: o,
+          entityId: e.original.versionEntityId || (a === "version" ? e.original.entityId : null),
+          entityType: "version",
+          isLoading: e.original.isLoading
         }
       );
     }
-  }), u("version") && ["version", "product"].some((i) => a.includes(i)) && y.push({
+  }), g("version") && ["version", "product"].some((e) => n.includes(e)) && y.push({
     id: "version",
     accessorKey: "version",
-    header: "Version",
+    header: v("version"),
     minSize: T,
-    enableSorting: v("version"),
+    sortDescFirst: j.version.sortDescFirst,
+    enableSorting: S("version"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(j),
-    cell: ({ row: i, column: e }) => {
-      const { value: t, id: n, type: o } = f(i, e.id);
-      if (["group", h].includes(o) || i.original.metaType) return null;
-      let r = i.original.versionName || t;
-      return i.original.entityType === "product" && (r = `${i.original.versionName} (${i.original.versionsCount || 0} versions)`), /* @__PURE__ */ s.jsx(
-        b,
+    sortingFn: C(z(F.basic)),
+    cell: ({ row: e, column: i }) => {
+      const { value: t, id: r, type: a } = f(e, i.id);
+      return ["group", h].includes(a) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: n,
-          className: g("version", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: r,
-          attributeData: { type: "string" },
+          rowId: r,
+          className: b("version", { loading: e.original.isLoading }),
+          columnId: i.id,
+          value: t ?? "",
+          attributeData: { type: "integer" },
           isReadOnly: !0
         }
       );
     }
-  }), u("product") && ["version", "product"].some((i) => a.includes(i)) && y.push({
+  }), g("product") && ["version", "product"].some((e) => n.includes(e)) && y.push({
     id: "product",
     accessorKey: "product",
-    header: "Product name",
+    header: v("product"),
     minSize: T,
-    enableSorting: v("product"),
+    enableSorting: S("product"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(j),
-    cell: ({ row: i, column: e }) => {
-      const { value: t, id: n, type: o } = f(i, e.id);
-      return ["group", h].includes(o) || i.original.metaType ? null : /* @__PURE__ */ s.jsx(
-        b,
+    sortingFn: C(_),
+    cell: ({ row: e, column: i }) => {
+      const { value: t, id: r, type: a } = f(e, i.id);
+      return ["group", h].includes(a) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: n,
-          className: g("product", { loading: i.original.isLoading }),
-          columnId: e.id,
+          rowId: r,
+          className: b("product", { loading: e.original.isLoading }),
+          columnId: i.id,
           value: t,
           attributeData: { type: "string" },
           isReadOnly: !0
         }
       );
     }
-  }), u("tags") && y.push({
+  }), g("tags") && y.push({
     id: "tags",
     accessorKey: "tags",
-    header: "Tags",
+    header: v("tags"),
     minSize: T,
-    enableSorting: v("tags"),
+    enableSorting: S("tags"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(E(X)),
-    cell: ({ row: i, column: e, table: t }) => {
-      const n = t.options.meta, { value: o, id: r, type: l } = f(i, e.id);
-      return ["group", h].includes(l) || i.original.metaType ? null : /* @__PURE__ */ s.jsx(
-        b,
+    sortingFn: C(z(Q)),
+    cell: ({ row: e, column: i, table: t }) => {
+      const r = t.options.meta, { value: a, id: o, type: s } = f(e, i.id);
+      return ["group", h].includes(s) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: r,
-          className: g("tags", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: o,
+          rowId: o,
+          className: b("tags", { loading: e.original.isLoading }),
+          columnId: i.id,
+          value: a,
           attributeData: { type: "list_of_strings" },
-          options: n?.options?.tag,
-          isCollapsed: !!i.original.childOnlyMatch,
-          onChange: (m) => n?.updateEntities?.(
-            { field: e.id, value: m, type: l, rowId: i.id },
-            { selection: n?.selection }
+          options: r?.options?.tag,
+          isCollapsed: !!e.original.childOnlyMatch,
+          onChange: (m) => r?.updateEntities?.(
+            { field: i.id, value: m, type: s, rowId: e.id },
+            { selection: r?.selection }
           ),
-          isReadOnly: n?.readOnly?.includes(e.id) || M(l),
+          isReadOnly: r?.readOnly?.includes(i.id) || G(s),
           enableCustomValues: !0
         }
       );
     }
-  }), u("createdAt") && y.push({
+  }), g("createdAt") && y.push({
     id: "createdAt",
     accessorKey: "createdAt",
-    header: "Created at",
+    header: v("createdAt"),
     minSize: T,
-    enableSorting: v("createdAt"),
+    enableSorting: S("createdAt"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(E(k.datetime)),
-    cell: ({ row: i, column: e }) => {
-      const { value: t, id: n, type: o } = f(i, e.id);
-      return ["group", h].includes(o) || i.original.metaType ? null : /* @__PURE__ */ s.jsx(
-        b,
+    sortingFn: C(z(F.datetime)),
+    cell: ({ row: e, column: i }) => {
+      const { value: t, id: r, type: a } = f(e, i.id);
+      return ["group", h].includes(a) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: n,
-          className: g("createdAt", { loading: i.original.isLoading }),
-          columnId: e.id,
+          rowId: r,
+          className: b("createdAt", { loading: e.original.isLoading }),
+          columnId: i.id,
           value: t,
           attributeData: { type: "datetime" },
-          isCollapsed: !!i.original.childOnlyMatch,
+          isCollapsed: !!e.original.childOnlyMatch,
           isReadOnly: !0,
           pt: { date: { showTime: !0 } }
         }
       );
     }
-  }), u("updatedAt") && y.push({
+  }), g("updatedAt") && y.push({
     id: "updatedAt",
     accessorKey: "updatedAt",
-    header: "Updated at",
+    header: v("updatedAt"),
     minSize: T,
-    enableSorting: v("updatedAt"),
+    enableSorting: S("updatedAt"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    sortingFn: x(E(k.datetime)),
-    cell: ({ row: i, column: e }) => {
-      const { value: t, id: n, type: o } = f(i, e.id);
-      return ["group", h].includes(o) || i.original.metaType ? null : /* @__PURE__ */ s.jsx(
-        b,
+    sortingFn: C(z(F.datetime)),
+    cell: ({ row: e, column: i }) => {
+      const { value: t, id: r, type: a } = f(e, i.id);
+      return ["group", h].includes(a) || e.original.metaType ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: n,
-          className: g("updatedAt", { loading: i.original.isLoading }),
-          columnId: e.id,
+          rowId: r,
+          className: b("updatedAt", { loading: e.original.isLoading }),
+          columnId: i.id,
           value: t,
           attributeData: { type: "datetime" },
-          isCollapsed: !!i.original.childOnlyMatch,
+          isCollapsed: !!e.original.childOnlyMatch,
           isReadOnly: !0,
           pt: { date: { showTime: !0 } }
         }
       );
     }
-  }), u("subtasks") && a.includes("task") && y.push({
+  }), g("subtasks") && n.includes("task") && y.push({
     id: "subtasks",
     accessorKey: "subtasks",
-    header: "Subtasks",
+    header: v("subtasks"),
     minSize: T,
     enableSorting: !1,
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    cell: ({ row: i, column: e, table: t }) => {
-      const n = t.options.meta, { value: o, id: r, type: l } = f(i, e.id);
-      if (["group", h].includes(l) || i.original.metaType) return null;
-      if (l !== "task") return /* @__PURE__ */ s.jsx("div", { className: "readonly" });
+    cell: ({ row: e, column: i, table: t }) => {
+      const r = t.options.meta, { value: a, id: o, type: s } = f(e, i.id);
+      if (["group", h].includes(s) || e.original.metaType) return null;
+      if (s !== "task") return /* @__PURE__ */ d.jsx("div", { className: "readonly" });
       const m = {
-        taskId: si(i.id) || i.original.entityId || i.original.id,
-        subtasks: o || []
+        taskId: ce(e.id) || e.original.entityId || e.original.id,
+        subtasks: a || []
       };
-      return /* @__PURE__ */ s.jsx(
-        b,
+      return /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: r,
-          className: g("subtasks", { loading: i.original.isLoading }),
-          columnId: e.id,
-          value: m.subtasks?.map((S) => S.label || S.name) || [],
+          rowId: o,
+          className: b("subtasks", { loading: e.original.isLoading }),
+          columnId: i.id,
+          value: m.subtasks?.map((k) => k.label || k.name) || [],
           valueData: m,
           attributeData: { type: "subtasks" },
-          isReadOnly: n?.readOnly?.includes(e.id)
+          isReadOnly: r?.readOnly?.includes(i.id)
         }
       );
     }
-  }), u("comments") && a.some((i) => ["task", "version", "product", "folder"].includes(i)) && y.push({
+  }), g("comments") && n.some((e) => ["task", "version", "product", "folder"].includes(e)) && y.push({
     id: "comments",
     accessorKey: "latestComments",
-    header: "Latest comments",
+    header: v("comments"),
     minSize: T,
     enableSorting: !1,
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    cell: ({ row: i, column: e }) => {
-      const { value: t, id: n, type: o } = f(i, "latestComments");
-      return ["group", h].includes(o) || i.original.metaType ? null : !i.original.isLoading && !["task", "version", "product", "folder"].includes(o) ? /* @__PURE__ */ s.jsx("div", { className: "readonly" }) : /* @__PURE__ */ s.jsx(
-        b,
+    cell: ({ row: e, column: i }) => {
+      const { value: t, id: r, type: a } = f(e, "latestComments");
+      return ["group", h].includes(a) || e.original.metaType ? null : !e.original.isLoading && !["task", "version", "product", "folder"].includes(a) ? /* @__PURE__ */ d.jsx("div", { className: "readonly" }) : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: n,
-          className: g("comments", { loading: i.original.isLoading }),
-          columnId: e.id,
+          rowId: r,
+          className: b("comments", { loading: e.original.isLoading }),
+          columnId: i.id,
           value: "",
           valueData: t || [],
           attributeData: { type: "comments" },
-          isCollapsed: !!i.original.childOnlyMatch,
+          isCollapsed: !!e.original.childOnlyMatch,
           isReadOnly: !0
         }
       );
     }
   });
-  const J = p.filter((i) => {
-    if (i.scope && !i.scope.some((t) => a.includes(t))) return !1;
-    const e = "attrib_" + i.name;
-    return !(!u(e) || i.builtin && !u("attrib"));
-  }).map((i) => ({
-    id: "attrib_" + i.name,
-    accessorKey: "attrib." + i.name,
-    header: i.data.title || i.name,
+  const te = p.filter((e) => {
+    if (e.scope && !e.scope.some((t) => n.includes(t))) return !1;
+    const i = "attrib_" + e.name;
+    return !(!g(i) || e.builtin && !g("attrib"));
+  }).map((e) => ({
+    id: "attrib_" + e.name,
+    accessorKey: "attrib." + e.name,
+    header: e.data.title || e.name,
     minSize: T,
     filterFn: "fuzzy",
-    sortingFn: x(
-      E((t, n, o) => V(t, n, o, i.data))
+    sortingFn: C(
+      z((t, r, a) => Y(t, r, a, e.data))
     ),
-    enableSorting: v(i.name) && v("attrib"),
+    enableSorting: S(e.name) && S("attrib"),
     enableResizing: !0,
     enablePinning: !0,
     enableHiding: !0,
-    cell: ({ row: t, column: n, table: o }) => {
-      const r = o.options.meta, l = n.id.replace("attrib_", ""), { value: m, id: S, type: C } = f(t, l, "attrib"), O = !t.original.ownAttrib?.includes(l);
-      return ["group", h].includes(C) || t.original.metaType || !i.scope?.includes(C) && m == null ? null : /* @__PURE__ */ s.jsx(
-        b,
+    cell: ({ row: t, column: r, table: a }) => {
+      const o = a.options.meta, s = r.id.replace("attrib_", ""), { value: m, id: k, type: N } = f(t, s, "attrib"), A = !t.original.ownAttrib?.includes(s);
+      return ["group", h].includes(N) || t.original.metaType || !e.scope?.includes(N) && m == null ? null : /* @__PURE__ */ d.jsx(
+        x,
         {
-          rowId: S,
-          className: g("attrib", { loading: t.original.isLoading }),
-          columnId: n.id,
+          rowId: k,
+          className: b("attrib", { loading: t.original.isLoading }),
+          columnId: r.id,
           value: m,
-          attributeData: { type: i.data.type || "string", widget: i.data.widget },
-          options: i.data.enum || [],
+          attributeData: { type: e.data.type || "string", widget: e.data.widget },
+          options: e.data.enum || [],
           midnightExclusiveFields: t.original.midnightExclusiveFields,
           isCollapsed: !!t.original.childOnlyMatch,
-          isInherited: O,
+          isInherited: A,
           isReadOnly: (
             // check attrib is not read only
-            i.readOnly || // check if there is any other reason the cell should be read only
-            r?.readOnly?.some(
-              (z) => z === l || z === "attrib" && i.builtin
+            e.readOnly || // check if there is any other reason the cell should be read only
+            o?.readOnly?.some(
+              (D) => D === s || D === "attrib" && e.builtin
             )
           ),
-          onChange: (z) => r?.updateEntities?.(
-            { field: l, value: z, type: C, isAttrib: !0, rowId: t.id },
-            { selection: i.data.enum?.length ? r?.selection : void 0 }
+          onChange: (D) => o?.updateEntities?.(
+            { field: s, value: D, type: N, isAttrib: !0, rowId: t.id },
+            { selection: e.data.enum?.length ? o?.selection : void 0 }
           )
         }
       );
     }
-  })), Q = c ? d.filter((i) => !(!u(i.linkType) || !u("link") || !a.includes(i.inputType) && !a.includes(i.outputType))).flatMap((i) => {
-    const e = (t) => ({
-      id: yi(i, t),
-      accessorKey: `links.${Z(i, t)}`,
-      header: () => /* @__PURE__ */ s.jsxs(ni, { children: [
-        ci(i, t),
+  })), ne = u ? l.filter((e) => !(!g(e.linkType) || !g("link") || !n.includes(e.inputType) && !n.includes(e.outputType))).flatMap((e) => {
+    const i = (t) => ({
+      id: Se(e, t),
+      accessorKey: `links.${ee(e, t)}`,
+      header: () => /* @__PURE__ */ d.jsxs(pe, { children: [
+        Ie(e, t),
         " ",
-        /* @__PURE__ */ s.jsx(
-          W,
+        /* @__PURE__ */ d.jsx(
+          Z,
           {
-            icon: G(t === "in" ? i.inputType : i.outputType)
+            icon: q(t === "in" ? e.inputType : e.outputType)
           }
         )
       ] }),
@@ -964,50 +1130,56 @@ const gi = (a) => ["folder", "product"].includes(a), T = 50, x = (a) => (p, d, .
       enableResizing: !0,
       enablePinning: !0,
       enableHiding: !0,
-      cell: ({ row: n, column: o, table: r }) => {
-        const l = o.id.replace("link_", ""), { id: m, value: S } = f(n, l, "links"), C = S?.map((B) => B.label), O = n.original.entityId || n.original.id, P = !!r.options.meta?.loadingLinksEntityIds?.has(O), z = {
-          links: S,
+      cell: ({ row: r, column: a, table: o }) => {
+        const s = a.id.replace("link_", ""), { id: m, value: k } = f(r, s, "links"), N = k?.map((re) => re.label), A = r.original.entityId || r.original.id, V = !!o.options.meta?.loadingLinksEntityIds?.has(A), D = {
+          links: k,
           direction: t,
-          entityId: O,
-          entityType: n.original.entityType,
+          entityId: A,
+          entityType: r.original.entityType,
           link: {
-            label: i.linkType,
-            linkType: i.name,
-            targetEntityType: t === "in" ? i.inputType : i.outputType
+            label: e.linkType,
+            linkType: e.name,
+            targetEntityType: t === "in" ? e.inputType : e.outputType
           }
         };
-        return /* @__PURE__ */ s.jsx(
-          b,
+        return /* @__PURE__ */ d.jsx(
+          x,
           {
             rowId: m,
-            className: g("links", { loading: n.original.isLoading }),
-            columnId: o.id,
-            value: C,
-            valueData: z,
-            folderId: n.original.folderId,
+            className: b("links", { loading: r.original.isLoading }),
+            columnId: a.id,
+            value: N,
+            valueData: D,
+            folderId: r.original.folderId,
             attributeData: { type: "links" },
-            isLinksLoading: P
+            isLinksLoading: V
           }
         );
       }
     });
-    return [e("in"), e("out")];
-  }) : [], H = [...y, ...J, ...Q];
-  return $ && $.forEach(({ column: i, position: e = -1 }) => {
-    e >= 0 && e < H.length ? H.splice(e, 0, i) : H.push(i);
-  }), H;
-}, f = (a, p, d) => ({
-  value: d ? a.original[d]?.[p] : a.original[p],
-  id: a.id,
-  type: a.original.entityType
+    return [i("in"), i("out")];
+  }) : [], M = [...y, ...te, ...ne];
+  return X && X.forEach(({ column: e, position: i = -1 }) => {
+    i >= 0 && i < M.length ? M.splice(i, 0, e) : M.push(e);
+  }), M;
+}, f = (n, p, l) => ({
+  value: l ? n.original[l]?.[p] : n.original[p],
+  id: n.id,
+  type: n.original.entityType
 });
 export {
+  c as COLUMN_LABELS,
   T as COLUMN_MIN_SIZE,
-  na as default,
-  yi as getLinkColumnId,
-  Z as getLinkKey,
-  ci as getLinkLabel,
+  j as COLUMN_SORT_CONFIG,
+  yo as default,
+  v as getColumnLabel,
+  co as getColumnSortKey,
+  Se as getLinkColumnId,
+  ee as getLinkKey,
+  Ie as getLinkLabel,
+  go as getSortableColumnOptions,
   f as getValueIdType,
-  gi as isEntityExpandable
+  ve as isColumnSortable,
+  Te as isEntityExpandable
 };
 //# sourceMappingURL=buildTreeTableColumns.es.js.map