@elliemae/ds-left-navigation 3.80.0-next.58 → 3.80.0-next.60

package/dist/cjs/exported-related/conversion-utils/index.js

@@ -0,0 +1,95 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conversion_utils_exports = {};
+__export(conversion_utils_exports, {
+  checkAndConvertItems: () => checkAndConvertItems
+});
+module.exports = __toCommonJS(conversion_utils_exports);
+var React = __toESM(require("react"));
+var import_conversionConstants = require("./conversionConstants.js");
+var import_conversionHelpers = require("./conversionHelpers.js");
+var import_validateIds = require("./validateIds.js");
+var import_getHumanReadableWarnings = require("./getHumanReadableWarnings.js");
+var import_report = require("./report.js");
+const reportIgnoredHeaderContent = (dsId, childrenByParentId, report) => {
+  if (!dsId || !(0, import_conversionConstants.getOwn)(childrenByParentId, dsId)) return;
+  (0, import_report.markLost)(report, {
+    code: "header-content-dropped",
+    dsId,
+    message: "The header is the first leaf, so its list in childrenByParentId was ignored"
+  });
+};
+const convertHeaderPart = (args) => {
+  const { HeaderComponent, headerAsFirstLeaf, convertedItems, report, childrenByParentId } = args;
+  const result = {};
+  const header = HeaderComponent ? (0, import_conversionHelpers.convertHeader)(HeaderComponent, report) : null;
+  if (!HeaderComponent || !header) return result;
+  if (headerAsFirstLeaf) {
+    convertedItems.unshift(header);
+    reportIgnoredHeaderContent(HeaderComponent.dsId, childrenByParentId, report);
+    return result;
+  }
+  const headerContent = HeaderComponent.dsId ? (0, import_conversionConstants.getOwn)(childrenByParentId, HeaderComponent.dsId) : void 0;
+  if (!headerContent) {
+    (0, import_report.markLost)(report, {
+      code: "header-without-content",
+      dsId: HeaderComponent.dsId ?? "",
+      message: "No entry in childrenByParentId for the header, it is a disclosure with nothing to open"
+    });
+  }
+  return {
+    convertedHeader: header,
+    convertedHeaderItems: headerContent ? (0, import_conversionHelpers.convertList)({ list: headerContent, isRoot: true, report, childrenByParentId }) : []
+  };
+};
+const checkAndConvertItems = (items, options = {}) => {
+  const { childrenByParentId = {}, HeaderComponent, BodyHeaderComponent, headerAsFirstLeaf = false } = options;
+  const report = (0, import_report.createEmptyReport)();
+  const convertedItems = (0, import_conversionHelpers.convertList)({ list: items, isRoot: true, report, childrenByParentId });
+  const { convertedHeader, convertedHeaderItems } = convertHeaderPart({
+    HeaderComponent,
+    headerAsFirstLeaf,
+    convertedItems,
+    report,
+    childrenByParentId
+  });
+  (0, import_validateIds.reportIdProblems)(convertedItems, report, convertedHeader ? [convertedHeader.dsId] : []);
+  if (convertedHeaderItems)
+    (0, import_validateIds.reportIdProblems)(convertedHeaderItems, report, convertedHeader?.dsId ? [convertedHeader.dsId] : []);
+  if (BodyHeaderComponent) {
+    (0, import_report.markLost)(report, {
+      code: "body-header-dropped",
+      dsId: BodyHeaderComponent.dsId ?? "",
+      message: "BodyHeaderComponent is not supported, the submenu is the parent of its children"
+    });
+  }
+  report.humanReadableWarnings = (0, import_getHumanReadableWarnings.getHumanReadableWarnings)(report);
+  return { convertedItems, convertedHeader, convertedHeaderItems, report };
+};
+//# sourceMappingURL=index.js.map

package/dist/cjs/exported-related/conversion-utils/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/exported-related/conversion-utils/index.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { getOwn } from './conversionConstants.js';\nimport { convertHeader, convertList } from './conversionHelpers.js';\nimport { reportIdProblems } from './validateIds.js';\nimport { getHumanReadableWarnings } from './getHumanReadableWarnings.js';\nimport { createEmptyReport, markLost } from './report.js';\nimport type { DSLeftNavBridgeT } from './types.js';\nimport type { DSLeftNavigationT } from '../../react-desc-prop-types.js';\n\ntype ConvertHeaderPartArgsT = {\n  HeaderComponent?: DSLeftNavBridgeT.OptionsT['HeaderComponent'];\n  headerAsFirstLeaf: boolean;\n  convertedItems: DSLeftNavBridgeT.ResultT['convertedItems'];\n  report: DSLeftNavBridgeT.ReportMutableT;\n  childrenByParentId: DSLeftNavBridgeT.ChildrenByParentIdT;\n};\n\nconst reportIgnoredHeaderContent = (\n  dsId: string | undefined,\n  childrenByParentId: DSLeftNavBridgeT.ChildrenByParentIdT,\n  report: DSLeftNavBridgeT.ReportMutableT,\n) => {\n  if (!dsId || !getOwn(childrenByParentId, dsId)) return;\n  markLost(report, {\n    code: 'header-content-dropped',\n    dsId,\n    message: 'The header is the first leaf, so its list in childrenByParentId was ignored',\n  });\n};\n\nconst convertHeaderPart = (args: ConvertHeaderPartArgsT) => {\n  const { HeaderComponent, headerAsFirstLeaf, convertedItems, report, childrenByParentId } = args;\n  const result: Pick<DSLeftNavBridgeT.ResultT, 'convertedHeader' | 'convertedHeaderItems'> = {};\n  const header = HeaderComponent ? convertHeader(HeaderComponent, report) : null;\n  if (!HeaderComponent || !header) return result;\n  if (headerAsFirstLeaf) {\n    convertedItems.unshift(header);\n    reportIgnoredHeaderContent(HeaderComponent.dsId, childrenByParentId, report);\n    return result;\n  }\n  const headerContent = HeaderComponent.dsId ? getOwn(childrenByParentId, HeaderComponent.dsId) : undefined;\n  if (!headerContent) {\n    markLost(report, {\n      code: 'header-without-content',\n      dsId: HeaderComponent.dsId ?? '',\n      message: 'No entry in childrenByParentId for the header, it is a disclosure with nothing to open',\n    });\n  }\n  return {\n    convertedHeader: header,\n    convertedHeaderItems: headerContent\n      ? convertList({ list: headerContent, isRoot: true, report, childrenByParentId })\n      : [],\n  };\n};\n\n/**\n * Converts LeftNavigation items to DSLeftNavigationTree items and reports what the tree cannot carry over.\n * It is a migration aid, not a drop-in replacement: read `report.humanReadableWarnings` and `report.lostEntries`.\n * @param items - The LeftNavigation items (the flat list shown by the body).\n * @param options - Children of the submenus (`childrenByParentId`), and the `HeaderComponent` and `BodyHeaderComponent` props.\n * @returns The converted items and the report. `HeaderComponent` becomes `convertedHeader`, a disclosure, and\n * `convertedHeaderItems` is its content (the list under the header `dsId` in `childrenByParentId`) to pass as `items`\n * while it is open. A header that is only a link goes to the front of `convertedItems` with `headerAsFirstLeaf`.\n */\nexport const checkAndConvertItems = (\n  items: readonly DSLeftNavigationT.GenericItemItemProps[],\n  options: DSLeftNavBridgeT.OptionsT = {},\n): DSLeftNavBridgeT.ResultT => {\n  const { childrenByParentId = {}, HeaderComponent, BodyHeaderComponent, headerAsFirstLeaf = false } = options;\n  const report = createEmptyReport();\n  const convertedItems = convertList({ list: items, isRoot: true, report, childrenByParentId });\n  const { convertedHeader, convertedHeaderItems } = convertHeaderPart({\n    HeaderComponent,\n    headerAsFirstLeaf,\n    convertedItems,\n    report,\n    childrenByParentId,\n  });\n  /** The header and each list the consumer passes as `items` are one hierarchy for the tree, so each is validated with the header. */\n  reportIdProblems(convertedItems, report, convertedHeader ? [convertedHeader.dsId] : []);\n  if (convertedHeaderItems)\n    reportIdProblems(convertedHeaderItems, report, convertedHeader?.dsId ? [convertedHeader.dsId] : []);\n  if (BodyHeaderComponent) {\n    markLost(report, {\n      code: 'body-header-dropped',\n      dsId: BodyHeaderComponent.dsId ?? '',\n      message: 'BodyHeaderComponent is not supported, the submenu is the parent of its children',\n    });\n  }\n  report.humanReadableWarnings = getHumanReadableWarnings(report);\n  return { convertedItems, convertedHeader, convertedHeaderItems, report };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,iCAAuB;AACvB,+BAA2C;AAC3C,yBAAiC;AACjC,sCAAyC;AACzC,oBAA4C;AAY5C,MAAM,6BAA6B,CACjC,MACA,oBACA,WACG;AACH,MAAI,CAAC,QAAQ,KAAC,mCAAO,oBAAoB,IAAI,EAAG;AAChD,8BAAS,QAAQ;AAAA,IACf,MAAM;AAAA,IACN;AAAA,IACA,SAAS;AAAA,EACX,CAAC;AACH;AAEA,MAAM,oBAAoB,CAAC,SAAiC;AAC1D,QAAM,EAAE,iBAAiB,mBAAmB,gBAAgB,QAAQ,mBAAmB,IAAI;AAC3F,QAAM,SAAqF,CAAC;AAC5F,QAAM,SAAS,sBAAkB,wCAAc,iBAAiB,MAAM,IAAI;AAC1E,MAAI,CAAC,mBAAmB,CAAC,OAAQ,QAAO;AACxC,MAAI,mBAAmB;AACrB,mBAAe,QAAQ,MAAM;AAC7B,+BAA2B,gBAAgB,MAAM,oBAAoB,MAAM;AAC3E,WAAO;AAAA,EACT;AACA,QAAM,gBAAgB,gBAAgB,WAAO,mCAAO,oBAAoB,gBAAgB,IAAI,IAAI;AAChG,MAAI,CAAC,eAAe;AAClB,gCAAS,QAAQ;AAAA,MACf,MAAM;AAAA,MACN,MAAM,gBAAgB,QAAQ;AAAA,MAC9B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AACA,SAAO;AAAA,IACL,iBAAiB;AAAA,IACjB,sBAAsB,oBAClB,sCAAY,EAAE,MAAM,eAAe,QAAQ,MAAM,QAAQ,mBAAmB,CAAC,IAC7E,CAAC;AAAA,EACP;AACF;AAWO,MAAM,uBAAuB,CAClC,OACA,UAAqC,CAAC,MACT;AAC7B,QAAM,EAAE,qBAAqB,CAAC,GAAG,iBAAiB,qBAAqB,oBAAoB,MAAM,IAAI;AACrG,QAAM,aAAS,iCAAkB;AACjC,QAAM,qBAAiB,sCAAY,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ,mBAAmB,CAAC;AAC5F,QAAM,EAAE,iBAAiB,qBAAqB,IAAI,kBAAkB;AAAA,IAClE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,2CAAiB,gBAAgB,QAAQ,kBAAkB,CAAC,gBAAgB,IAAI,IAAI,CAAC,CAAC;AACtF,MAAI;AACF,6CAAiB,sBAAsB,QAAQ,iBAAiB,OAAO,CAAC,gBAAgB,IAAI,IAAI,CAAC,CAAC;AACpG,MAAI,qBAAqB;AACvB,gCAAS,QAAQ;AAAA,MACf,MAAM;AAAA,MACN,MAAM,oBAAoB,QAAQ;AAAA,MAClC,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AACA,SAAO,4BAAwB,0DAAyB,MAAM;AAC9D,SAAO,EAAE,gBAAgB,iBAAiB,sBAAsB,OAAO;AACzE;",
+  "names": []
+}

package/dist/cjs/exported-related/conversion-utils/lostCodes.js

@@ -0,0 +1,55 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lostCodes_exports = {};
+__export(lostCodes_exports, {
+  WARNING_PER_LOST_CODE: () => WARNING_PER_LOST_CODE
+});
+module.exports = __toCommonJS(lostCodes_exports);
+var React = __toESM(require("react"));
+const WARNING_PER_LOST_CODE = {
+  "submenu-without-children": `- Encountered submenu items without an entry in "childrenByParentId" - the tree needs the children in the data, the conversion created an empty parent`,
+  "custom-component-dropped": `- Encountered items with a custom "Component" - a treeitem cannot hold arbitrary interactive content (WCAG 4.1.2), the conversion dropped them`,
+  "skeleton-dropped": `- Encountered skeleton items - loading states are not part of the tree, the conversion dropped them`,
+  "header-item-dropped": `- Encountered an item of type header inside "items" - the tree has one header disclosure, passed as "HeaderComponent", the conversion dropped it from the list`,
+  "header-content-dropped": `- Encountered "headerAsFirstLeaf" together with a list for the header in "childrenByParentId" - a header that is the first item of the list has nothing to open, the conversion ignored that list. Drop "headerAsFirstLeaf" to keep the header as a disclosure with its content`,
+  "header-without-content": `- Encountered a "HeaderComponent" without an entry in "childrenByParentId" - the tree header is a disclosure with nothing to open. If the header is only a link, pass "headerAsFirstLeaf" to make it the first item of the list`,
+  "right-component-ctx": `- Encountered "RightComponent" on a leaf, drilldown or header, or a "labelRightSection" that is not text - the conversion kept it, but the tree only gives it "{ item }" and an empty "ctx", so it must not read "ctx". The "item" it receives is the converted tree item (another type, with only the options the tree keeps), so it must not read legacy fields either. The conversion does not inspect what it draws: remove buttons, menus or any other control inside it before rendering the converted data, a treeitem cannot hold them`,
+  "body-header-dropped": `- Encountered "BodyHeaderComponent" - the tree shows the opened submenu as the parent of its children, the conversion ignored it`,
+  "component-with-ctx-dropped": `- Encountered "LeftComponent" or "BottomComponent", or a "RightComponent" on a submenu or section - the tree has no place for them (parents draw their own arrow), the conversion dropped them`,
+  "collapsed-component-ctx": `- Encountered "CollapsedComponent" - the conversion kept it as is, but the tree only gives it "{ item }" with the converted tree item (another type, with only the options the tree keeps), so it must not read "ctx" or legacy fields of the item`,
+  "label-style-dropped": `- Encountered "labelBold" or "labelColor" - state conveyed only by weight or color fails WCAG 1.3.1 and 1.4.1, the conversion dropped them`,
+  "label-truncate-to-wrap": `- Encountered "labelOverflow: truncate" - truncated labels need a hover tooltip (1.4.13) and hide text from users who zoom (1.4.10), the conversion uses "wrap"`,
+  "aria-overrides-dropped": `- Encountered "ariaLabel", "ariaRole", "ariaLive", "ariaExpanded" or "ariaDescribedBy" - the tree computes its own names and states, the conversion dropped them`,
+  "item-options-dropped": `- Encountered item options the tree does not have (selectable on a drilldown, focuseable, openable, closable, indent, skeletonVariant, labelDataTestId, any other key of itemOpts, or a non-text labelRightSection where it cannot be shown) - the conversion dropped them, see lostEntries for the list per item`,
+  "section-in-nested-list-dropped": `- Encountered a section or separator inside a submenu or drilldown - the tree supports them only at the root level, the conversion dropped them`,
+  "missing-id": `- Encountered items without a "dsId" - the tree finds every item by its "dsId", so each one needs its own; set it before using the converted items`,
+  "duplicate-id": `- Encountered the same "dsId" on more than one item of the converted hierarchy - the tree finds items by "dsId" across all levels, so a repeated one overwrites the other's label and parent; give each item a unique "dsId" (LeftNavigation only needed it unique inside the list that is shown)`,
+  "unknown-type-dropped": `- Encountered items with a type that is not out of the box, or a "HeaderComponent" that is not a header, link, text-label or with-date - the conversion dropped them`
+};
+//# sourceMappingURL=lostCodes.js.map

package/dist/cjs/exported-related/conversion-utils/lostCodes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/exported-related/conversion-utils/lostCodes.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/**\n * Single source of truth for the codes of what the conversion cannot carry over: the type, the empty report and the warnings derive from it.\n */\nexport const WARNING_PER_LOST_CODE = {\n  'submenu-without-children': `- Encountered submenu items without an entry in \"childrenByParentId\" - the tree needs the children in the data, the conversion created an empty parent`,\n  'custom-component-dropped': `- Encountered items with a custom \"Component\" - a treeitem cannot hold arbitrary interactive content (WCAG 4.1.2), the conversion dropped them`,\n  'skeleton-dropped': `- Encountered skeleton items - loading states are not part of the tree, the conversion dropped them`,\n  'header-item-dropped': `- Encountered an item of type header inside \"items\" - the tree has one header disclosure, passed as \"HeaderComponent\", the conversion dropped it from the list`,\n  'header-content-dropped': `- Encountered \"headerAsFirstLeaf\" together with a list for the header in \"childrenByParentId\" - a header that is the first item of the list has nothing to open, the conversion ignored that list. Drop \"headerAsFirstLeaf\" to keep the header as a disclosure with its content`,\n  'header-without-content': `- Encountered a \"HeaderComponent\" without an entry in \"childrenByParentId\" - the tree header is a disclosure with nothing to open. If the header is only a link, pass \"headerAsFirstLeaf\" to make it the first item of the list`,\n  'right-component-ctx': `- Encountered \"RightComponent\" on a leaf, drilldown or header, or a \"labelRightSection\" that is not text - the conversion kept it, but the tree only gives it \"{ item }\" and an empty \"ctx\", so it must not read \"ctx\". The \"item\" it receives is the converted tree item (another type, with only the options the tree keeps), so it must not read legacy fields either. The conversion does not inspect what it draws: remove buttons, menus or any other control inside it before rendering the converted data, a treeitem cannot hold them`,\n  'body-header-dropped': `- Encountered \"BodyHeaderComponent\" - the tree shows the opened submenu as the parent of its children, the conversion ignored it`,\n  'component-with-ctx-dropped': `- Encountered \"LeftComponent\" or \"BottomComponent\", or a \"RightComponent\" on a submenu or section - the tree has no place for them (parents draw their own arrow), the conversion dropped them`,\n  'collapsed-component-ctx': `- Encountered \"CollapsedComponent\" - the conversion kept it as is, but the tree only gives it \"{ item }\" with the converted tree item (another type, with only the options the tree keeps), so it must not read \"ctx\" or legacy fields of the item`,\n  'label-style-dropped': `- Encountered \"labelBold\" or \"labelColor\" - state conveyed only by weight or color fails WCAG 1.3.1 and 1.4.1, the conversion dropped them`,\n  'label-truncate-to-wrap': `- Encountered \"labelOverflow: truncate\" - truncated labels need a hover tooltip (1.4.13) and hide text from users who zoom (1.4.10), the conversion uses \"wrap\"`,\n  'aria-overrides-dropped': `- Encountered \"ariaLabel\", \"ariaRole\", \"ariaLive\", \"ariaExpanded\" or \"ariaDescribedBy\" - the tree computes its own names and states, the conversion dropped them`,\n  'item-options-dropped': `- Encountered item options the tree does not have (selectable on a drilldown, focuseable, openable, closable, indent, skeletonVariant, labelDataTestId, any other key of itemOpts, or a non-text labelRightSection where it cannot be shown) - the conversion dropped them, see lostEntries for the list per item`,\n  'section-in-nested-list-dropped': `- Encountered a section or separator inside a submenu or drilldown - the tree supports them only at the root level, the conversion dropped them`,\n  'missing-id': `- Encountered items without a \"dsId\" - the tree finds every item by its \"dsId\", so each one needs its own; set it before using the converted items`,\n  'duplicate-id': `- Encountered the same \"dsId\" on more than one item of the converted hierarchy - the tree finds items by \"dsId\" across all levels, so a repeated one overwrites the other's label and parent; give each item a unique \"dsId\" (LeftNavigation only needed it unique inside the list that is shown)`,\n  'unknown-type-dropped': `- Encountered items with a type that is not out of the box, or a \"HeaderComponent\" that is not a header, link, text-label or with-date - the conversion dropped them`,\n} as const;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADGhB,MAAM,wBAAwB;AAAA,EACnC,4BAA4B;AAAA,EAC5B,4BAA4B;AAAA,EAC5B,oBAAoB;AAAA,EACpB,uBAAuB;AAAA,EACvB,0BAA0B;AAAA,EAC1B,0BAA0B;AAAA,EAC1B,uBAAuB;AAAA,EACvB,uBAAuB;AAAA,EACvB,8BAA8B;AAAA,EAC9B,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,0BAA0B;AAAA,EAC1B,0BAA0B;AAAA,EAC1B,wBAAwB;AAAA,EACxB,kCAAkC;AAAA,EAClC,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,wBAAwB;AAC1B;",
+  "names": []
+}

package/dist/cjs/exported-related/conversion-utils/report.js

@@ -0,0 +1,48 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var report_exports = {};
+__export(report_exports, {
+  createEmptyReport: () => createEmptyReport,
+  markLost: () => markLost
+});
+module.exports = __toCommonJS(report_exports);
+var React = __toESM(require("react"));
+var import_lostCodes = require("./lostCodes.js");
+const createEmptyReport = () => ({
+  detectedLostsOnConversion: Object.fromEntries(
+    Object.keys(import_lostCodes.WARNING_PER_LOST_CODE).map((code) => [code, false])
+  ),
+  lostEntries: [],
+  humanReadableWarnings: []
+});
+const markLost = (report, entry) => {
+  report.detectedLostsOnConversion[entry.code] = true;
+  report.lostEntries.push(entry);
+};
+//# sourceMappingURL=report.js.map

package/dist/cjs/exported-related/conversion-utils/report.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/exported-related/conversion-utils/report.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { WARNING_PER_LOST_CODE } from './lostCodes.js';\nimport type { DSLeftNavBridgeT } from './types.js';\n\nexport const createEmptyReport = (): DSLeftNavBridgeT.ReportMutableT => ({\n  detectedLostsOnConversion: Object.fromEntries(\n    Object.keys(WARNING_PER_LOST_CODE).map((code) => [code, false]),\n  ) as DSLeftNavBridgeT.ReportMutableT['detectedLostsOnConversion'],\n  lostEntries: [],\n  humanReadableWarnings: [],\n});\n\nexport const markLost = (report: DSLeftNavBridgeT.ReportMutableT, entry: DSLeftNavBridgeT.LostEntryT) => {\n  // eslint-disable-next-line no-param-reassign\n  report.detectedLostsOnConversion[entry.code] = true;\n  report.lostEntries.push(entry);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,uBAAsC;AAG/B,MAAM,oBAAoB,OAAwC;AAAA,EACvE,2BAA2B,OAAO;AAAA,IAChC,OAAO,KAAK,sCAAqB,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;AAAA,EAChE;AAAA,EACA,aAAa,CAAC;AAAA,EACd,uBAAuB,CAAC;AAC1B;AAEO,MAAM,WAAW,CAAC,QAAyC,UAAuC;AAEvG,SAAO,0BAA0B,MAAM,IAAI,IAAI;AAC/C,SAAO,YAAY,KAAK,KAAK;AAC/B;",
+  "names": []
+}

package/dist/cjs/exported-related/conversion-utils/types.js

@@ -0,0 +1,28 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+var React = __toESM(require("react"));
+//# sourceMappingURL=types.js.map

package/dist/cjs/exported-related/conversion-utils/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/exported-related/conversion-utils/types.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { DSLeftNavigationTreeT } from '@elliemae/ds-left-navigation-tree';\nimport type { WARNING_PER_LOST_CODE } from './lostCodes.js';\nimport type { DSLeftNavigationT } from '../../react-desc-prop-types.js';\n\nexport declare namespace DSLeftNavBridgeT {\n  /**\n   * Each code is something LeftNavigation could do that the tree cannot carry over.\n   */\n  export type LostCodeT = keyof typeof WARNING_PER_LOST_CODE;\n\n  export type LostEntryT = {\n    code: LostCodeT;\n    dsId: string;\n    message: string;\n  };\n\n  export type ReportMutableT = {\n    detectedLostsOnConversion: Record<LostCodeT, boolean>;\n    lostEntries: LostEntryT[];\n    humanReadableWarnings: string[];\n  };\n\n  /**\n   * LeftNavigation keeps the hierarchy outside of the data: a submenu has no children in its item, the consumer swaps `items` when the submenu is opened.\n   * This map gives the bridge the lists the consumer swaps in, keyed by the submenu dsId.\n   */\n  export type ChildrenByParentIdT = Record<string, readonly DSLeftNavigationT.GenericItemItemProps[]>;\n\n  export type OptionsT = {\n    childrenByParentId?: ChildrenByParentIdT;\n    HeaderComponent?: DSLeftNavigationT.GenericItemItemProps;\n    BodyHeaderComponent?: DSLeftNavigationT.GenericItemItemProps;\n    /** The header is only a link, with nothing to open: it becomes the first item of the list instead of a disclosure. */\n    headerAsFirstLeaf?: boolean;\n  };\n\n  export type ResultT = {\n    convertedItems: DSLeftNavigationTreeT.Item[];\n    convertedHeader?: DSLeftNavigationTreeT.Item;\n    convertedHeaderItems?: DSLeftNavigationTreeT.Item[];\n    report: ReportMutableT;\n  };\n}\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;",
+  "names": []
+}

package/dist/cjs/exported-related/conversion-utils/validateIds.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validateIds_exports = {};
+__export(validateIds_exports, {
+  reportIdProblems: () => reportIdProblems
+});
+module.exports = __toCommonJS(validateIds_exports);
+var React = __toESM(require("react"));
+var import_report = require("./report.js");
+const collectIds = (items, ids = []) => {
+  items.forEach((item) => {
+    ids.push(item.dsId);
+    collectIds(item.itemOpts?.items ?? [], ids);
+  });
+  return ids;
+};
+const reportIdProblems = (items, report, extraIds = []) => {
+  const seen = /* @__PURE__ */ new Set();
+  const reported = /* @__PURE__ */ new Set();
+  [...extraIds, ...collectIds(items)].forEach((dsId) => {
+    if (!dsId) {
+      (0, import_report.markLost)(report, { code: "missing-id", dsId: "", message: "An item has no dsId" });
+      return;
+    }
+    if (seen.has(dsId) && !reported.has(dsId)) {
+      reported.add(dsId);
+      (0, import_report.markLost)(report, { code: "duplicate-id", dsId, message: "The dsId is used by more than one item" });
+    }
+    seen.add(dsId);
+  });
+};
+//# sourceMappingURL=validateIds.js.map

package/dist/cjs/exported-related/conversion-utils/validateIds.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/exported-related/conversion-utils/validateIds.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { DSLeftNavigationTreeT } from '@elliemae/ds-left-navigation-tree';\nimport { markLost } from './report.js';\nimport type { DSLeftNavBridgeT } from './types.js';\n\ntype NewItemT = DSLeftNavigationTreeT.Item;\n\nconst collectIds = (items: readonly NewItemT[], ids: string[] = []): string[] => {\n  items.forEach((item) => {\n    ids.push(item.dsId);\n    collectIds(item.itemOpts?.items ?? [], ids);\n  });\n  return ids;\n};\n\n/**\n * The tree finds items by `dsId` across every level of the list it receives, LeftNavigation only needed them unique inside each list it showed.\n * Reports the items without one and the ids that repeat, once per repeated id.\n */\nexport const reportIdProblems = (\n  items: readonly NewItemT[],\n  report: DSLeftNavBridgeT.ReportMutableT,\n  extraIds: readonly string[] = [],\n) => {\n  const seen = new Set<string>();\n  const reported = new Set<string>();\n  [...extraIds, ...collectIds(items)].forEach((dsId) => {\n    if (!dsId) {\n      markLost(report, { code: 'missing-id', dsId: '', message: 'An item has no dsId' });\n      return;\n    }\n    if (seen.has(dsId) && !reported.has(dsId)) {\n      reported.add(dsId);\n      markLost(report, { code: 'duplicate-id', dsId, message: 'The dsId is used by more than one item' });\n    }\n    seen.add(dsId);\n  });\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,oBAAyB;AAKzB,MAAM,aAAa,CAAC,OAA4B,MAAgB,CAAC,MAAgB;AAC/E,QAAM,QAAQ,CAAC,SAAS;AACtB,QAAI,KAAK,KAAK,IAAI;AAClB,eAAW,KAAK,UAAU,SAAS,CAAC,GAAG,GAAG;AAAA,EAC5C,CAAC;AACD,SAAO;AACT;AAMO,MAAM,mBAAmB,CAC9B,OACA,QACA,WAA8B,CAAC,MAC5B;AACH,QAAM,OAAO,oBAAI,IAAY;AAC7B,QAAM,WAAW,oBAAI,IAAY;AACjC,GAAC,GAAG,UAAU,GAAG,WAAW,KAAK,CAAC,EAAE,QAAQ,CAAC,SAAS;AACpD,QAAI,CAAC,MAAM;AACT,kCAAS,QAAQ,EAAE,MAAM,cAAc,MAAM,IAAI,SAAS,sBAAsB,CAAC;AACjF;AAAA,IACF;AACA,QAAI,KAAK,IAAI,IAAI,KAAK,CAAC,SAAS,IAAI,IAAI,GAAG;AACzC,eAAS,IAAI,IAAI;AACjB,kCAAS,QAAQ,EAAE,MAAM,gBAAgB,MAAM,SAAS,yCAAyC,CAAC;AAAA,IACpG;AACA,SAAK,IAAI,IAAI;AAAA,EACf,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/index.js

@@ -50,12 +50,14 @@ __export(index_exports, {
   MAP_ITEMS_TO_SKELETON: () => import_constants.MAP_ITEMS_TO_SKELETON,
   Notifications: () => import_exported_related.Notifications,
   OpenWindow: () => import_exported_related.OpenWindow,
+  checkAndConvertItems: () => import_conversion_utils.checkAndConvertItems,
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
 var React = __toESM(require("react"));
 var import_LeftNavigation = require("./LeftNavigation.js");
 var import_constants = require("./constants/index.js");
+var import_conversion_utils = require("./exported-related/conversion-utils/index.js");
 var import_exported_related = require("./exported-related/index.js");
 var import_LeftNavigation2 = require("./LeftNavigation.js");
 var import_react_desc_prop_types = require("./react-desc-prop-types.js");

package/dist/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { LeftNavigation } from './LeftNavigation.js';\n\nexport default LeftNavigation;\nexport {\n  CHEVRON_BACK_DS_ID,\n  DSLeftNavigationName,\n  DSLeftNavigationSlots,\n  FOOTER_DS_ID,\n  FOOTER_MENU_CLOSE_DS_ID,\n  ITEM_TYPES,\n  LABEL_OVERFLOW,\n  LEFT_NAVIGATION_DATA_TESTID,\n  LEFT_NAVIGATION_REGION_FOCUSES,\n  LEFT_NAVIGATION_SLOTS,\n  MAP_ITEMS_TO_SKELETON,\n} from './constants/index.js';\nexport { ChevronItem, Icon, ItemRenderer, Notifications, OpenWindow } from './exported-related/index.js';\nexport { LeftNavigation, LeftNavigationWithSchema } from './LeftNavigation.js';\nexport {\n  DSLeftNavigationItemPropTypesSchema,\n  DSLeftNavigationPropTypesSchema,\n  LeftNavItemOptionsSchema,\n  LeftNavItemPropsSchema,\n  type DSLeftNavigationT,\n} from './react-desc-prop-types.js';\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,4BAA+B;AAG/B,uBAYO;AACP,8BAA2E;AAC3E,IAAAA,yBAAyD;AACzD,mCAMO;AAtBP,IAAO,gBAAQ;",
+  "sourcesContent": ["import { LeftNavigation } from './LeftNavigation.js';\n\nexport default LeftNavigation;\nexport {\n  CHEVRON_BACK_DS_ID,\n  DSLeftNavigationName,\n  DSLeftNavigationSlots,\n  FOOTER_DS_ID,\n  FOOTER_MENU_CLOSE_DS_ID,\n  ITEM_TYPES,\n  LABEL_OVERFLOW,\n  LEFT_NAVIGATION_DATA_TESTID,\n  LEFT_NAVIGATION_REGION_FOCUSES,\n  LEFT_NAVIGATION_SLOTS,\n  MAP_ITEMS_TO_SKELETON,\n} from './constants/index.js';\nexport { checkAndConvertItems } from './exported-related/conversion-utils/index.js';\nexport type { DSLeftNavBridgeT } from './exported-related/conversion-utils/types.js';\nexport { ChevronItem, Icon, ItemRenderer, Notifications, OpenWindow } from './exported-related/index.js';\nexport { LeftNavigation, LeftNavigationWithSchema } from './LeftNavigation.js';\nexport {\n  DSLeftNavigationItemPropTypesSchema,\n  DSLeftNavigationPropTypesSchema,\n  LeftNavItemOptionsSchema,\n  LeftNavItemPropsSchema,\n  type DSLeftNavigationT,\n} from './react-desc-prop-types.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,4BAA+B;AAG/B,uBAYO;AACP,8BAAqC;AAErC,8BAA2E;AAC3E,IAAAA,yBAAyD;AACzD,mCAMO;AAxBP,IAAO,gBAAQ;",
   "names": ["import_LeftNavigation"]
 }

package/dist/esm/exported-related/conversion-utils/conversionConstants.js

@@ -0,0 +1,34 @@
+import * as React from "react";
+import { ITEM_TYPES } from "../../constants/index.js";
+const DRILLDOWN_TYPES = [
+  ITEM_TYPES.LEFT_NAV_ITEM_CONTROLLED_DRILLDOWN,
+  ITEM_TYPES.LEFT_NAV_ITEM_UNCONTROLLED_DRILLDOWN
+];
+const LEAF_TYPES = [
+  ITEM_TYPES.LEFT_NAV_ITEM_LINK,
+  ITEM_TYPES.LEFT_NAV_ITEM_TEXT_LABEL,
+  ITEM_TYPES.LEFT_NAV_ITEM_WITH_DATE
+];
+const getOwn = (map, key) => Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
+const HEADER_TYPES = [ITEM_TYPES.LEFT_NAV_ITEM_HEADER, ...LEAF_TYPES];
+const OUT_OF_THE_BOX_TYPES = Object.values(ITEM_TYPES);
+const NO_RAIL_TYPES = [
+  ITEM_TYPES.LEFT_NAV_ITEM_TEXT_LABEL,
+  ITEM_TYPES.LEFT_NAV_ITEM_WITH_DATE,
+  ITEM_TYPES.LEFT_NAV_ITEM_CONTROLLED_DRILLDOWN,
+  ITEM_TYPES.LEFT_NAV_ITEM_UNCONTROLLED_DRILLDOWN
+];
+const DROPPED_TYPE_CODES = {
+  [ITEM_TYPES.LEFT_NAV_ITEM_HEADER]: ["header-item-dropped", "Header items are not part of the list"],
+  [ITEM_TYPES.LEFT_NAV_ITEM_SKELETON]: ["skeleton-dropped", "Skeleton items are not supported"]
+};
+export {
+  DRILLDOWN_TYPES,
+  DROPPED_TYPE_CODES,
+  HEADER_TYPES,
+  LEAF_TYPES,
+  NO_RAIL_TYPES,
+  OUT_OF_THE_BOX_TYPES,
+  getOwn
+};
+//# sourceMappingURL=conversionConstants.js.map

package/dist/esm/exported-related/conversion-utils/conversionConstants.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../scripts/build/transpile/react-shim.js", "../../../../src/exported-related/conversion-utils/conversionConstants.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import { ITEM_TYPES } from '../../constants/index.js';\n\nexport const DRILLDOWN_TYPES: string[] = [\n  ITEM_TYPES.LEFT_NAV_ITEM_CONTROLLED_DRILLDOWN,\n  ITEM_TYPES.LEFT_NAV_ITEM_UNCONTROLLED_DRILLDOWN,\n];\nexport const LEAF_TYPES: string[] = [\n  ITEM_TYPES.LEFT_NAV_ITEM_LINK,\n  ITEM_TYPES.LEFT_NAV_ITEM_TEXT_LABEL,\n  ITEM_TYPES.LEFT_NAV_ITEM_WITH_DATE,\n];\n\n/**\n * Reads only own entries, so ids and types like \"constructor\" or \"toString\" do not resolve to inherited members.\n */\nexport const getOwn = <T>(map: Record<string, T>, key: string): T | undefined =>\n  Object.prototype.hasOwnProperty.call(map, key) ? map[key] : undefined;\n\n/**\n * The types a `HeaderComponent` can have and still be the tree header: a header, or a leaf when the header is only a link.\n */\nexport const HEADER_TYPES: string[] = [ITEM_TYPES.LEFT_NAV_ITEM_HEADER, ...LEAF_TYPES];\n\nexport const OUT_OF_THE_BOX_TYPES: string[] = Object.values(ITEM_TYPES);\n\n/**\n * LeftNavigation renders no `CollapsedComponent` for these types (it forces it to null), so they were never in its rail.\n */\nexport const NO_RAIL_TYPES: string[] = [\n  ITEM_TYPES.LEFT_NAV_ITEM_TEXT_LABEL,\n  ITEM_TYPES.LEFT_NAV_ITEM_WITH_DATE,\n  ITEM_TYPES.LEFT_NAV_ITEM_CONTROLLED_DRILLDOWN,\n  ITEM_TYPES.LEFT_NAV_ITEM_UNCONTROLLED_DRILLDOWN,\n];\n\nexport const DROPPED_TYPE_CODES = {\n  [ITEM_TYPES.LEFT_NAV_ITEM_HEADER]: ['header-item-dropped', 'Header items are not part of the list'],\n  [ITEM_TYPES.LEFT_NAV_ITEM_SKELETON]: ['skeleton-dropped', 'Skeleton items are not supported'],\n} as const;\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,SAAS,kBAAkB;AAEpB,MAAM,kBAA4B;AAAA,EACvC,WAAW;AAAA,EACX,WAAW;AACb;AACO,MAAM,aAAuB;AAAA,EAClC,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AACb;AAKO,MAAM,SAAS,CAAI,KAAwB,QAChD,OAAO,UAAU,eAAe,KAAK,KAAK,GAAG,IAAI,IAAI,GAAG,IAAI;AAKvD,MAAM,eAAyB,CAAC,WAAW,sBAAsB,GAAG,UAAU;AAE9E,MAAM,uBAAiC,OAAO,OAAO,UAAU;AAK/D,MAAM,gBAA0B;AAAA,EACrC,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AACb;AAEO,MAAM,qBAAqB;AAAA,EAChC,CAAC,WAAW,oBAAoB,GAAG,CAAC,uBAAuB,uCAAuC;AAAA,EAClG,CAAC,WAAW,sBAAsB,GAAG,CAAC,oBAAoB,kCAAkC;AAC9F;",
+  "names": []
+}

package/dist/esm/exported-related/conversion-utils/conversionHelpers.js

@@ -0,0 +1,172 @@
+import * as React from "react";
+import {
+  LEFT_NAVIGATION_TREE_ITEM_TYPES as TREE_TYPES
+} from "@elliemae/ds-left-navigation-tree";
+import { ITEM_TYPES } from "../../constants/index.js";
+import {
+  DRILLDOWN_TYPES,
+  DROPPED_TYPE_CODES,
+  HEADER_TYPES,
+  LEAF_TYPES,
+  NO_RAIL_TYPES,
+  OUT_OF_THE_BOX_TYPES,
+  getOwn
+} from "./conversionConstants.js";
+import { convertItemOpts } from "./convertItemOpts.js";
+import { markLost } from "./report.js";
+const convertCollapsed = (item, report) => {
+  if (!item.CollapsedComponent || NO_RAIL_TYPES.includes(item.type ?? "")) return {};
+  markLost(report, {
+    code: "collapsed-component-ctx",
+    dsId: item.dsId ?? "",
+    message: "CollapsedComponent is kept, it only receives { item }"
+  });
+  return { CollapsedComponent: item.CollapsedComponent };
+};
+const joinSectionLabel = (label, rightSection) => typeof label === "string" && typeof rightSection === "string" ? `${label}, ${rightSection}` : label;
+const convertSubmenu = (item, args) => {
+  const { report, childrenByParentId, recurse } = args;
+  const dsId = item.dsId ?? "";
+  const children = getOwn(childrenByParentId, dsId);
+  if (!children)
+    markLost(report, { code: "submenu-without-children", dsId, message: "No entry in childrenByParentId" });
+  return {
+    dsId,
+    type: TREE_TYPES.PARENT,
+    ...convertCollapsed(item, report),
+    itemOpts: { ...convertItemOpts({ item, report, kind: "submenu" }), items: recurse(children ?? []) }
+  };
+};
+const convertDrilldown = (item, args) => {
+  const { report, recurse } = args;
+  const dsId = item.dsId ?? "";
+  const { startOpened, isOpened, items = [] } = item.itemOpts ?? {};
+  const opts = convertItemOpts({ item, report, kind: "drilldown" });
+  const isControlled = item.type === ITEM_TYPES.LEFT_NAV_ITEM_CONTROLLED_DRILLDOWN;
+  return {
+    dsId,
+    type: TREE_TYPES.PARENT,
+    ...convertCollapsed(item, report),
+    itemOpts: {
+      ...opts,
+      ...isControlled && { isOpened: !!isOpened },
+      ...!isControlled && startOpened !== void 0 && { startOpened },
+      items: recurse(items)
+    }
+  };
+};
+const convertOne = (item, args) => {
+  const { report } = args;
+  const dsId = item.dsId ?? "";
+  const { type } = item;
+  if (typeof type !== "string") {
+    markLost(report, {
+      code: "custom-component-dropped",
+      dsId,
+      message: "Items with a custom Component are not supported"
+    });
+    return null;
+  }
+  if (LEAF_TYPES.includes(type)) {
+    return {
+      dsId,
+      type: TREE_TYPES.LEAF,
+      ...convertCollapsed(item, report),
+      itemOpts: convertItemOpts({ item, report, kind: "leaf" })
+    };
+  }
+  if (type === ITEM_TYPES.LEFT_NAV_ITEM_SUBMENU) return convertSubmenu(item, args);
+  if (DRILLDOWN_TYPES.includes(type)) return convertDrilldown(item, args);
+  const [code, message] = getOwn(DROPPED_TYPE_CODES, type) ?? [
+    "unknown-type-dropped",
+    `Type "${type}" is not out of the box`
+  ];
+  markLost(report, { code, dsId, message });
+  return null;
+};
+const convertSection = (item, report, items) => {
+  const { label, labelRightSection } = item.itemOpts ?? {};
+  const joinable = typeof label === "string" && typeof labelRightSection === "string";
+  const opts = convertItemOpts({ item, report, kind: "section", joinable });
+  return {
+    dsId: item.dsId ?? "",
+    type: TREE_TYPES.SECTION,
+    itemOpts: {
+      ...opts,
+      label: joinSectionLabel(label, labelRightSection),
+      items
+    }
+  };
+};
+const convertList = (args) => {
+  const { list, isRoot, report, ancestors = [] } = args;
+  const converted = [];
+  let sectionItems = null;
+  list.forEach((item) => {
+    const { type, dsId = "" } = item;
+    const isSection = type === ITEM_TYPES.LEFT_NAV_ITEM_SECTION;
+    if (isSection || type === ITEM_TYPES.LEFT_NAV_ITEM_SEPARATOR) {
+      if (!isRoot) {
+        markLost(report, {
+          code: "section-in-nested-list-dropped",
+          dsId,
+          message: "Sections and separators are only supported at the root level"
+        });
+        return;
+      }
+      sectionItems = isSection ? [] : null;
+      converted.push(sectionItems ? convertSection(item, report, sectionItems) : { dsId, type: TREE_TYPES.SEPARATOR });
+      return;
+    }
+    const ancestorKey = dsId || item;
+    const isOwnAncestor = ancestors.includes(ancestorKey);
+    const convertedItem = convertOne(item, {
+      report,
+      childrenByParentId: args.childrenByParentId,
+      recurse: (children) => isOwnAncestor ? [] : convertList({ ...args, list: children, isRoot: false, ancestors: [...ancestors, ancestorKey] })
+    });
+    if (!convertedItem) return;
+    if (sectionItems) sectionItems.push(convertedItem);
+    else converted.push(convertedItem);
+  });
+  return converted;
+};
+const convertHeader = (header, report) => {
+  if (header.type === ITEM_TYPES.LEFT_NAV_ITEM_SKELETON) {
+    const [code, message] = DROPPED_TYPE_CODES[ITEM_TYPES.LEFT_NAV_ITEM_SKELETON];
+    markLost(report, { code, dsId: header.dsId ?? "", message });
+    return null;
+  }
+  if (typeof header.type !== "string" || !OUT_OF_THE_BOX_TYPES.includes(header.type)) {
+    markLost(report, {
+      code: "custom-component-dropped",
+      dsId: header.dsId ?? "",
+      message: "A HeaderComponent with a custom Component is not supported"
+    });
+    return null;
+  }
+  if (!HEADER_TYPES.includes(header.type)) {
+    markLost(report, {
+      code: "unknown-type-dropped",
+      dsId: header.dsId ?? "",
+      message: `A HeaderComponent of type "${header.type}" is not supported, use a header or a leaf type`
+    });
+    return null;
+  }
+  return {
+    dsId: header.dsId ?? "",
+    type: TREE_TYPES.LEAF,
+    ...convertCollapsed(header, report),
+    /** A header of a leaf type is drawn by LeftNavigation as that leaf (a with-date header shows its date), so it converts as one. */
+    itemOpts: convertItemOpts({
+      item: header,
+      report,
+      kind: header.type === ITEM_TYPES.LEFT_NAV_ITEM_HEADER ? "header" : "leaf"
+    })
+  };
+};
+export {
+  convertHeader,
+  convertList
+};
+//# sourceMappingURL=conversionHelpers.js.map