@truedat/dd 7.14.0 → 7.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dd",
-  "version": "7.14.0",
+  "version": "7.14.2",
   "description": "Truedat Web Data Dictionary",
   "sideEffects": false,
   "module": "src/index.js",
@@ -48,7 +48,7 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
-    "@truedat/test": "7.14.0",
+    "@truedat/test": "7.14.2",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^29.7.0",
     "redux-saga-test-plan": "^4.0.6"
@@ -83,5 +83,5 @@
     "svg-pan-zoom": "^3.6.2",
     "swr": "^2.3.3"
   },
-  "gitHead": "861787da648eec4a053e7982c59e1b140316d160"
+  "gitHead": "819dbd2c48ef3339194608f79a58d502fe6c01a6"
 }

package/src/components/StructureTabPane.js

@@ -65,7 +65,6 @@ export const StructureTabPane = ({ path }) => {
     structureTabsOrder,
     customTabs,
   });
-
   return (
     <ErrorBoundary>
       {activeTab === "fields" && <StructureFields />}

package/src/components/StructureTabs.js

@@ -184,7 +184,7 @@ export const StructureTabs = ({ path }) => {
       ])
     : null;
 
-  structureTabsOrder
+  const sortedItems = items && structureTabsOrder
     ? items.sort((a, b) => {
         const aIndex = _.indexOf(a.key)(structureTabsOrder);
         const bIndex = _.indexOf(b.key)(structureTabsOrder);
@@ -208,7 +208,7 @@ export const StructureTabs = ({ path }) => {
         secondary
         pointing
         tabular
-        items={items}
+        items={sortedItems}
         className="tab-overflow"
       />
       <Divider hidden />

package/src/components/StructuresRoutes.js

@@ -2,14 +2,7 @@ import _ from "lodash/fp";
 import React from "react";
 import { useIntl } from "react-intl";
 import { Routes, Route, useParams } from "react-router";
-import {
-  STRUCTURE,
-  STRUCTURES,
-  STRUCTURES_BULK_UPDATE,
-  STRUCTURE_EVENTS,
-  STRUCTURE_VERSION,
-  STRUCTURE_MEMBERS_NEW,
-} from "@truedat/core/routes";
+
 import { useSelector } from "react-redux";
 import AddStructureMember from "./AddStructureMember";
 import StructureCrumbs from "./StructureCrumbs";

package/src/components/__tests__/StructureTabs.spec.js

@@ -35,4 +35,58 @@ describe("<StructureTabs />", () => {
     await waitForLoad(rendered);
     expect(rendered.container).toMatchSnapshot();
   });
+
+  it("should render correctly with structureTabsOrder", async () => {
+    jest.spyOn(getTabVisibilityModule, "getTabVisibility").mockReturnValue(tabVisibility);
+
+    const structureTabsOrder = ["links", "notes", "fields", "profile"];
+    const props = { path: "/structures/:id" };
+    const rendered = render(<StructureTabs {...props} />, {
+      state: { structure, structureVersion: version, structureTabsOrder },
+    });
+    await waitForLoad(rendered);
+
+    const menuItems = rendered.container.querySelectorAll(".item");
+    expect(menuItems.length).toBeGreaterThan(0);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("should use default order when structureTabsOrder is empty", async () => {
+    jest.spyOn(getTabVisibilityModule, "getTabVisibility").mockReturnValue(tabVisibility);
+
+    const props = { path: "/structures/:id" };
+    const rendered = render(<StructureTabs {...props} />, {
+      state: { structure, structureVersion: version, structureTabsOrder: [] },
+    });
+    await waitForLoad(rendered);
+
+    const menuItems = rendered.container.querySelectorAll(".item");
+    expect(menuItems.length).toBeGreaterThan(0);
+  });
+
+  it("should handle structureTabsOrder with tabs not in items", async () => {
+    jest.spyOn(getTabVisibilityModule, "getTabVisibility").mockReturnValue(tabVisibility);
+
+    const structureTabsOrder = ["nonexistent", "fields", "notes"];
+    const props = { path: "/structures/:id" };
+    const rendered = render(<StructureTabs {...props} />, {
+      state: { structure, structureVersion: version, structureTabsOrder },
+    });
+    await waitForLoad(rendered);
+
+    const menuItems = rendered.container.querySelectorAll(".item");
+    expect(menuItems.length).toBeGreaterThan(0);
+  });
+
+  it("should not crash when structure is empty", async () => {
+    jest.spyOn(getTabVisibilityModule, "getTabVisibility").mockReturnValue(tabVisibility);
+
+    const props = { path: "/structures/:id" };
+    const rendered = render(<StructureTabs {...props} />, {
+      state: { structure: null, structureVersion: version, structureTabsOrder: [] },
+    });
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toBeTruthy();
+  });
 });

package/src/components/__tests__/__snapshots__/StructureTabs.spec.js.snap

@@ -81,3 +81,85 @@ exports[`<StructureTabs /> matches the latest snapshot: metadata 1`] = `
   />
 </div>
 `;
+
+exports[`<StructureTabs /> should render correctly with structureTabsOrder 1`] = `
+<div>
+  <div
+    class="ui pointing secondary top attached tabular tab-overflow menu"
+  >
+    <a
+      class="active item"
+      data-discover="true"
+      href="/structures/123/links"
+    >
+      tabs.dd.links
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/notes"
+    >
+      tabs.dd.notes
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/versions/1/fields"
+    >
+      tabs.dd.fields
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/profile"
+    >
+      tabs.dd.profile
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/grants"
+    >
+      tabs.dd.grants
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/metadata"
+    >
+      tabs.dd.metadata
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/rules"
+    >
+      tabs.dd.rules
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/versions/1/versions"
+    >
+      tabs.dd.versions
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/events"
+    >
+      tabs.dd.audit
+    </a>
+    <a
+      class="item"
+      data-discover="true"
+      href="/structures/123/members"
+    >
+      tabs.dd.roles
+    </a>
+  </div>
+  <div
+    class="ui hidden divider"
+  />
+</div>
+`;

package/src/selectors/__tests__/getActiveTab.spec.js

@@ -75,6 +75,68 @@ describe("selectors: defaultTab", () => {
     expect(defaultTab({ fields }, tabsOrder)).toBe("fields");
     expect(defaultTab({}, tabsOrder)).toBe(undefined);
   });
+
+  it("should return the first visible tab according to custom order when all tabs are visible", () => {
+    const tabsOrder = ["links", "fields", "notes", "metadata"];
+    const tabVisibility = {
+      links: true,
+      fields: true,
+      notes: true,
+      metadata: true,
+      children: true,
+      grants: true,
+    };
+    expect(defaultTab(tabVisibility, tabsOrder)).toBe("links");
+  });
+
+  it("should return the first visible tab in custom order, skipping invisible ones", () => {
+    const tabsOrder = ["links", "fields", "notes", "metadata"];
+    const tabVisibility = {
+      links: false,
+      fields: true,
+      notes: true,
+      metadata: true,
+    };
+    expect(defaultTab(tabVisibility, tabsOrder)).toBe("fields");
+  });
+
+  it("should include custom tabs in the order when provided", () => {
+    const tabsOrder = ["links", "fields"];
+    const customTabs = [{ name: "custom1" }, { name: "custom2" }];
+    const tabVisibility = {
+      links: false,
+      fields: false,
+    };
+    expect(defaultTab(tabVisibility, tabsOrder, customTabs)).toBe("custom1");
+  });
+
+  it("should place custom tabs after tabsOrder when tabsOrder is provided", () => {
+    const tabsOrder = ["links", "fields"];
+    const customTabs = [{ name: "custom1" }, { name: "custom2" }];
+    const tabVisibility = {
+      links: true,
+      fields: true,
+    };
+    expect(defaultTab(tabVisibility, tabsOrder, customTabs)).toBe("links");
+  });
+
+  it("should place custom tabs at the end when no tabsOrder is provided", () => {
+    const customTabs = [{ name: "custom1" }, { name: "custom2" }];
+    const tabVisibility = {
+      fields: true,
+    };
+    expect(defaultTab(tabVisibility, [], customTabs)).toBe("fields");
+  });
+
+  it("should return custom tab as first when it is first in tabsOrder", () => {
+    const tabsOrder = ["custom", "links", "fields"];
+    const customTabs = [{ name: "custom", route: "/structures/:id/custom" }];
+    const tabVisibility = {
+      links: true,
+      fields: true,
+    };
+    expect(defaultTab(tabVisibility, tabsOrder, customTabs)).toBe("custom");
+  });
 });
 
 describe("selectors: getActiveTab", () => {
@@ -103,4 +165,86 @@ describe("selectors: getActiveTab", () => {
     expect(getActiveTab({ tabVisibility, path: "foo" })).toBe(undefined);
     expect(getActiveTab({ tabVisibility, path: customPath, customTabs: [{ name: "custom", route: customPath }] })).toBe("custom");
   });
+
+  it("should return the first visible tab according to structureTabsOrder when path is STRUCTURE", () => {
+    const structureTabsOrder = ["links", "fields", "notes"];
+    const tabVisibility = {
+      links: true,
+      fields: true,
+      notes: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE, structureTabsOrder })).toBe("links");
+  });
+
+  it("should return the first visible tab according to structureTabsOrder when path is STRUCTURE_VERSION", () => {
+    const structureTabsOrder = ["notes", "fields", "links"];
+    const tabVisibility = {
+      notes: true,
+      fields: true,
+      links: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE_VERSION, structureTabsOrder })).toBe("notes");
+  });
+
+  it("should skip invisible tabs in structureTabsOrder and return the first visible one", () => {
+    const structureTabsOrder = ["links", "fields", "notes"];
+    const tabVisibility = {
+      links: false,
+      fields: true,
+      notes: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE, structureTabsOrder })).toBe("fields");
+  });
+
+  it("should return first visible tab from default order when all tabs in structureTabsOrder are invisible", () => {
+    const structureTabsOrder = ["links", "versions"];
+    const tabVisibility = {
+      links: false,
+      versions: false,
+      fields: true,
+      notes: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE, structureTabsOrder })).toBe("fields");
+  });
+
+  it("should handle tabs in structureTabsOrder that are not in tabVisibility", () => {
+    const structureTabsOrder = ["nonexistent", "fields", "notes"];
+    const tabVisibility = {
+      fields: true,
+      notes: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE, structureTabsOrder })).toBe("fields");
+  });
+
+  it("should handle structureLinks, lineage, and impact tabs in custom order", () => {
+    const structureTabsOrder = ["lineage", "structureLinks", "impact", "fields"];
+    const tabVisibility = {
+      lineage: true,
+      structureLinks: true,
+      impact: true,
+      fields: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE, structureTabsOrder })).toBe("lineage");
+  });
+
+  it("should return custom tab as first when it is first in structureTabsOrder", () => {
+    const structureTabsOrder = ["custom", "links", "fields", "notes"];
+    const customTabs = [{ name: "custom", route: "/structures/:id/custom" }];
+    const tabVisibility = {
+      links: true,
+      fields: true,
+      notes: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE, structureTabsOrder, customTabs })).toBe("custom");
+  });
+
+  it("should skip custom tab if it is not in customTabs array even if in structureTabsOrder", () => {
+    const structureTabsOrder = ["custom", "links", "fields"];
+    const customTabs = [];
+    const tabVisibility = {
+      links: true,
+      fields: true,
+    };
+    expect(getActiveTab({ tabVisibility, path: STRUCTURE, structureTabsOrder, customTabs })).toBe("links");
+  });
 });

package/src/selectors/getActiveTab.js

@@ -36,19 +36,41 @@ export const defaultTab = (tabVisibility, tabsOrder = [], customTabs = []) => {
     "rules",
     "roles",
     "links",
+    "structureLinks",
+    "lineage",
+    "impact",
     "versions",
-    ..._.map((tab) => tab.name)(customTabs),
+    "events",
   ];
 
-  return _.find((tab) => tabVisibility[tab])([...tabsOrder, ...defaultOrder]);
+  const customTabsNames = _.map((tab) => tab.name)(customTabs);
+  const customTabsNamesSet = new Set(customTabsNames);
+
+  const isTabVisible = (tab) => {
+    if (customTabsNamesSet.has(tab)) {
+      return true;
+    }
+    return tabVisibility[tab] === true;
+  };
+
+  if (_.isArray(tabsOrder) && _.size(tabsOrder) > 0) {
+    for (const tab of tabsOrder) {
+      if (isTabVisible(tab)) {
+        return tab;
+      }
+    }
+  }
+
+  const order = [...defaultOrder, ...customTabsNames];
+  return _.find((tab) => isTabVisible(tab))(order);
 };
 
-const getCustomTabs = (customTabs) => _.map((tab) => [_.eq(tab.route), _.constant(tab.name)])(customTabs)
+const getCustomTabs = (customTabs) => _.map((tab) => [_.eq(tab.route), _.constant(tab.name)])(customTabs);
 
-export const getActiveTab = ({ tabVisibility, path, tabsOrder, customTabs }) => {
+export const getActiveTab = ({ tabVisibility, path, structureTabsOrder, customTabs }) => {
   return _.cond([
-    [_.eq(STRUCTURE), _.constant(defaultTab(tabVisibility, tabsOrder, customTabs))],
-    [_.eq(STRUCTURE_VERSION), _.constant(defaultTab(tabVisibility, tabsOrder, customTabs))],
+    [_.eq(STRUCTURE), _.constant(defaultTab(tabVisibility, structureTabsOrder, customTabs))],
+    [_.eq(STRUCTURE_VERSION), _.constant(defaultTab(tabVisibility, structureTabsOrder, customTabs))],
     [_.eq(STRUCTURE_VERSION_FIELDS), _.constant("fields")],
     [_.eq(STRUCTURE_FIELDS), _.constant("fields")],
     [_.eq(STRUCTURE_CHILDREN), _.constant("children")],