@elliemae/ds-left-navigation-tree 0.0.0-stage → 3.80.0-next.38

package/dist/esm/typescript-testing/DSLeftNavigationTreeNamespace.js

@@ -0,0 +1,149 @@
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { DSLeftNavigationTree, LEFT_NAVIGATION_TREE_ITEM_TYPES } from "../index.js";
+const Icon = (_props) => /* @__PURE__ */ jsx("svg", { "aria-hidden": "true" });
+const Badge = ({ item }) => /* @__PURE__ */ jsx("span", { children: item.dsId });
+const items = [
+  {
+    dsId: "pipeline",
+    type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF,
+    CollapsedComponent: Icon,
+    itemOpts: { label: "Pipeline" }
+  },
+  {
+    dsId: "loan",
+    type: LEFT_NAVIGATION_TREE_ITEM_TYPES.PARENT,
+    CollapsedComponent: Icon,
+    itemOpts: {
+      label: "Loan",
+      startOpened: true,
+      RightComponent: Badge,
+      items: [{ dsId: "borrower", type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF, itemOpts: { label: "Borrower" } }]
+    }
+  },
+  { dsId: "separator", type: LEFT_NAVIGATION_TREE_ITEM_TYPES.SEPARATOR },
+  {
+    dsId: "tools",
+    type: LEFT_NAVIGATION_TREE_ITEM_TYPES.SECTION,
+    itemOpts: {
+      label: "Tools",
+      items: [
+        { dsId: "calculator", type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF, itemOpts: { label: "Calculator" } },
+        {
+          dsId: "contact-us",
+          type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF,
+          itemOpts: { label: "Contact us", selectable: false, labelOverflow: "wrapAll" }
+        }
+      ]
+    }
+  }
+];
+const controlledParent = {
+  dsId: "controlled",
+  type: LEFT_NAVIGATION_TREE_ITEM_TYPES.PARENT,
+  itemOpts: { label: "Controlled", isOpened: false, items: [] }
+};
+const header = {
+  dsId: "header",
+  type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF,
+  itemOpts: { label: "Loan summary" }
+};
+const testRequiredProps = {};
+const testOptionalProps = {
+  selectedItem: "borrower",
+  selectedParent: "loan",
+  HeaderComponent: header,
+  dsLeftnavigationtreeRoot: {
+    onClick: () => {
+    },
+    "data-testid": "over-ride-test-id",
+    "aria-label": "over-ride-aria-label"
+  }
+};
+const testPartialDefaults = {
+  items: [...items, controlledParent],
+  expanded: true
+};
+const testProps = {
+  ...testRequiredProps,
+  ...testOptionalProps,
+  ...testPartialDefaults
+};
+const testPropsAsSyntax = {
+  ...testRequiredProps,
+  ...testOptionalProps,
+  ...testPartialDefaults
+};
+const testCompleteDefaults = {
+  items,
+  expanded: false,
+  expandedWidth: "240px",
+  labelOverflow: "wrapAll",
+  footerLabel: "v1.0",
+  disableDefaultSelection: false,
+  openedItem: null,
+  onItemClick: (item, e) => {
+  },
+  onItemOpenedChange: (item, nextIsOpened, e) => {
+  },
+  onSelectedChange: (id) => {
+  },
+  onFocusChange: (id) => {
+  },
+  onFooterExpand: (e) => {
+  },
+  onFooterClose: (e) => {
+  }
+};
+const testInternalProps = {
+  ...testRequiredProps,
+  ...testOptionalProps,
+  ...testCompleteDefaults
+};
+const testInternalPropsAsSyntax = {
+  ...testRequiredProps,
+  ...testOptionalProps,
+  ...testCompleteDefaults
+};
+const itemSlot = ({ item, isCurrent }) => ({
+  "data-testid": isCurrent ? `current-${item.dsId}` : item.dsId
+});
+const testExplicitDefinition = {
+  items,
+  selectedItem: null,
+  labelOverflow: "wrap",
+  onItemOpenedChange: (item, nextIsOpened) => {
+  },
+  dsLeftnavigationtreeItem: itemSlot
+};
+const testInferedTypeCompatibility = {
+  items,
+  expanded: true,
+  footerLabel: /* @__PURE__ */ jsx("span", { children: "v1.0" })
+};
+const testDefinitionAsConst = {
+  items,
+  labelOverflow: "wrapAll",
+  openedItem: "header"
+};
+const ExampleUsageComponent = () => /* @__PURE__ */ jsxs(Fragment, { children: [
+  /* @__PURE__ */ jsx(DSLeftNavigationTree, { ...testExplicitDefinition }),
+  /* @__PURE__ */ jsx(
+    DSLeftNavigationTree,
+    {
+      items,
+      expanded: true,
+      selectedItem: "borrower",
+      HeaderComponent: header,
+      openedItem: null,
+      onItemClick: (item, e) => {
+      },
+      onSelectedChange: (id) => {
+      },
+      "aria-label": "Loan"
+    }
+  ),
+  /* @__PURE__ */ jsx(DSLeftNavigationTree, { ...testInferedTypeCompatibility }),
+  /* @__PURE__ */ jsx(DSLeftNavigationTree, { ...testDefinitionAsConst })
+] });
+//# sourceMappingURL=DSLeftNavigationTreeNamespace.js.map

package/dist/esm/typescript-testing/DSLeftNavigationTreeNamespace.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/typescript-testing/DSLeftNavigationTreeNamespace.tsx"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */\nimport { DSLeftNavigationTree, LEFT_NAVIGATION_TREE_ITEM_TYPES, type DSLeftNavigationTreeT } from '../index.js';\n\n// test we expose the namespace and the namespace follows our deliverable conventions\ntype ComponentPropsForApp = DSLeftNavigationTreeT.Props;\ntype ComponentPropsInternals = DSLeftNavigationTreeT.InternalProps;\ntype ComponentPropsDefaultProps = DSLeftNavigationTreeT.DefaultProps;\ntype ComponentPropsOptionalProps = DSLeftNavigationTreeT.OptionalProps;\ntype ComponentPropsRequiredProps = DSLeftNavigationTreeT.RequiredProps;\n\nconst Icon = (_props: DSLeftNavigationTreeT.ItemComponentProps) => <svg aria-hidden=\"true\" />;\nconst Badge = ({ item }: DSLeftNavigationTreeT.ItemComponentProps) => <span>{item.dsId}</span>;\n\nconst items: DSLeftNavigationTreeT.Item[] = [\n  {\n    dsId: 'pipeline',\n    type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF,\n    CollapsedComponent: Icon,\n    itemOpts: { label: 'Pipeline' },\n  },\n  {\n    dsId: 'loan',\n    type: LEFT_NAVIGATION_TREE_ITEM_TYPES.PARENT,\n    CollapsedComponent: Icon,\n    itemOpts: {\n      label: 'Loan',\n      startOpened: true,\n      RightComponent: Badge,\n      items: [{ dsId: 'borrower', type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF, itemOpts: { label: 'Borrower' } }],\n    },\n  },\n  { dsId: 'separator', type: LEFT_NAVIGATION_TREE_ITEM_TYPES.SEPARATOR },\n  {\n    dsId: 'tools',\n    type: LEFT_NAVIGATION_TREE_ITEM_TYPES.SECTION,\n    itemOpts: {\n      label: 'Tools',\n      items: [\n        { dsId: 'calculator', type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF, itemOpts: { label: 'Calculator' } },\n        {\n          dsId: 'contact-us',\n          type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF,\n          itemOpts: { label: 'Contact us', selectable: false, labelOverflow: 'wrapAll' },\n        },\n      ],\n    },\n  },\n];\n\nconst controlledParent = {\n  dsId: 'controlled',\n  type: LEFT_NAVIGATION_TREE_ITEM_TYPES.PARENT,\n  itemOpts: { label: 'Controlled', isOpened: false, items: [] },\n} as const;\n\nconst header = {\n  dsId: 'header',\n  type: LEFT_NAVIGATION_TREE_ITEM_TYPES.LEAF,\n  itemOpts: { label: 'Loan summary' },\n} as DSLeftNavigationTreeT.Item;\n\nconst testRequiredProps: ComponentPropsRequiredProps = {};\n\nconst testOptionalProps: ComponentPropsOptionalProps = {\n  selectedItem: 'borrower',\n  selectedParent: 'loan',\n  HeaderComponent: header,\n  dsLeftnavigationtreeRoot: {\n    onClick: () => {},\n    'data-testid': 'over-ride-test-id',\n    'aria-label': 'over-ride-aria-label',\n  },\n};\n\n// difference Props and InternalProps is that InternalProps has all the default props filled in\n// Props allows for partial defaults\nconst testPartialDefaults: Partial<ComponentPropsDefaultProps> = {\n  items: [...items, controlledParent],\n  expanded: true,\n};\n\nconst testProps: ComponentPropsForApp = {\n  ...testRequiredProps,\n  ...testOptionalProps,\n  ...testPartialDefaults,\n};\n\nconst testPropsAsSyntax = {\n  ...testRequiredProps,\n  ...testOptionalProps,\n  ...testPartialDefaults,\n} as ComponentPropsForApp;\n\n// InternalProps requires all defaults to be filled in\nconst testCompleteDefaults: Required<ComponentPropsDefaultProps> = {\n  items,\n  expanded: false,\n  expandedWidth: '240px',\n  labelOverflow: 'wrapAll',\n  footerLabel: 'v1.0',\n  disableDefaultSelection: false,\n  openedItem: null,\n  onItemClick: (item, e) => {},\n  onItemOpenedChange: (item, nextIsOpened, e) => {},\n  onSelectedChange: (id) => {},\n  onFocusChange: (id) => {},\n  onFooterExpand: (e) => {},\n  onFooterClose: (e) => {},\n};\n\nconst testInternalProps: ComponentPropsInternals = {\n  ...testRequiredProps,\n  ...testOptionalProps,\n  ...testCompleteDefaults,\n};\n\nconst testInternalPropsAsSyntax = {\n  ...testRequiredProps,\n  ...testOptionalProps,\n  ...testCompleteDefaults,\n} as ComponentPropsInternals;\n\n// per-node slot functions receive { item, level, isOpen, isCurrent }; consumers type them through SlotFunctionArguments\nconst itemSlot: DSLeftNavigationTreeT.SlotFunctionArguments['dsLeftnavigationtreeItem'] = ({ item, isCurrent }) => ({\n  'data-testid': isCurrent ? `current-${item.dsId}` : item.dsId,\n});\n\n// using the explicit type definition, if there is an error, it will be marked on the key that is wrong\nconst testExplicitDefinition: ComponentPropsForApp = {\n  items,\n  selectedItem: null,\n  labelOverflow: 'wrap',\n  onItemOpenedChange: (item, nextIsOpened) => {},\n  dsLeftnavigationtreeItem: itemSlot,\n};\n\n// using the \"as\" syntax, if there is an error, it will be marking the whole object as wrong because it is not compatible with the type\nconst testInferedTypeCompatibility = {\n  items,\n  expanded: true,\n  footerLabel: <span>v1.0</span>,\n} as ComponentPropsForApp;\n\nconst testDefinitionAsConst = {\n  items,\n  labelOverflow: 'wrapAll',\n  openedItem: 'header',\n} as const;\n\nconst ExampleUsageComponent = () => (\n  <>\n    {/* works with spread operator */}\n    <DSLeftNavigationTree {...testExplicitDefinition} />\n    {/* works with inline values */}\n    <DSLeftNavigationTree\n      items={items}\n      expanded\n      selectedItem=\"borrower\"\n      HeaderComponent={header}\n      openedItem={null}\n      onItemClick={(item, e) => {}}\n      onSelectedChange={(id) => {}}\n      aria-label=\"Loan\"\n    />\n    <DSLeftNavigationTree {...testInferedTypeCompatibility} />\n    <DSLeftNavigationTree {...testDefinitionAsConst} />\n  </>\n);\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/typescript-testing/slot-props.js

@@ -0,0 +1,59 @@
+import * as React from "react";
+const SlotPropsAsObject = {
+  dsLeftnavigationtreeRoot: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeTree: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeItem: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeItemRow: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeItemLabel: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeLeftContainer: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeCollapsedContainer: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeRightContainer: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeArrowContainer: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeGroup: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeSectionContainer: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeSectionLabel: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeItemSeparator: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeHeaderDisclosure: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeFooterMenu: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeFooterLabel: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeFooterSeparator: { "aria-label": "just a typescript test" },
+  dsLeftnavigationtreeFooterMenuCollapse: { "aria-label": "just a typescript test" }
+};
+const SlotPropsAsFunctions = {
+  dsLeftnavigationtreeRoot: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeTree: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeItem: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeItemRow: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeItemLabel: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeLeftContainer: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeCollapsedContainer: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeRightContainer: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeArrowContainer: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeGroup: ({ item, level, isOpen, isCurrent }) => ({
+    "aria-label": `${item.dsId} ${level} ${isOpen} ${isCurrent}`
+  }),
+  dsLeftnavigationtreeSectionContainer: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeSectionLabel: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeItemSeparator: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeHeaderDisclosure: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeFooterMenu: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeFooterLabel: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeFooterSeparator: () => ({ "aria-label": "just a typescript test" }),
+  dsLeftnavigationtreeFooterMenuCollapse: () => ({ "aria-label": "just a typescript test" })
+};
+const EnsureAllSlotsExistInSlotFunctionArguments = SlotPropsAsFunctions;
+//# sourceMappingURL=slot-props.js.map

package/dist/esm/typescript-testing/slot-props.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/typescript-testing/slot-props.ts"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */\n\nimport type { TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';\nimport type { DSLeftNavigationTreeName, LEFT_NAVIGATION_TREE_SLOTS } from '../constants/index.js';\nimport type { DSLeftNavigationTreeT } from '../react-desc-prop-types.js';\n\nconst SlotPropsAsObject: Partial<DSLeftNavigationTreeT.Props> = {\n  dsLeftnavigationtreeRoot: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeTree: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeItem: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeItemRow: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeItemLabel: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeLeftContainer: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeCollapsedContainer: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeRightContainer: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeArrowContainer: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeGroup: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeSectionContainer: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeSectionLabel: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeItemSeparator: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeHeaderDisclosure: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeFooterMenu: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeFooterLabel: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeFooterSeparator: { 'aria-label': 'just a typescript test' },\n  dsLeftnavigationtreeFooterMenuCollapse: { 'aria-label': 'just a typescript test' },\n};\n\nconst SlotPropsAsFunctions: DSLeftNavigationTreeT.SlotFunctionArguments = {\n  dsLeftnavigationtreeRoot: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeTree: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeItem: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeItemRow: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeItemLabel: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeLeftContainer: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeCollapsedContainer: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeRightContainer: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeArrowContainer: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeGroup: ({ item, level, isOpen, isCurrent }) => ({\n    'aria-label': `${item.dsId} ${level} ${isOpen} ${isCurrent}`,\n  }),\n  dsLeftnavigationtreeSectionContainer: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeSectionLabel: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeItemSeparator: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeHeaderDisclosure: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeFooterMenu: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeFooterLabel: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeFooterSeparator: () => ({ 'aria-label': 'just a typescript test' }),\n  dsLeftnavigationtreeFooterMenuCollapse: () => ({ 'aria-label': 'just a typescript test' }),\n};\n\n// Exhaustiveness check \u2014 fails compilation if a slot is missing from SlotFunctionArguments\nconst EnsureAllSlotsExistInSlotFunctionArguments: Required<\n  TypescriptHelpersT.PropsForSlots<typeof DSLeftNavigationTreeName, typeof LEFT_NAVIGATION_TREE_SLOTS>\n> = SlotPropsAsFunctions;\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/DSLeftNavigationTree.d.ts

@@ -0,0 +1,4 @@
+import { type DSLeftNavigationTreeT } from './react-desc-prop-types.js';
+declare const DSLeftNavigationTree: import("react").FunctionComponent<DSLeftNavigationTreeT.Props>;
+declare const DSLeftNavigationTreeWithSchema: import("@elliemae/ds-props-helpers/dist/types/propTypes/types.js").DocumentedReactComponent<DSLeftNavigationTreeT.Props>;
+export { DSLeftNavigationTree, DSLeftNavigationTreeWithSchema };

package/dist/types/config/store.d.ts

@@ -0,0 +1,38 @@
+import { type ZustandT } from '@elliemae/ds-zustand-helpers';
+import { type DSLeftNavigationTreeT } from '../react-desc-prop-types.js';
+export declare const PropsProvider: ({ createStore, children, }: {
+    createStore: () => ZustandT.ZustandStore<ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>>;
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>> | undefined>>, usePropsStore: {
+    (): ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>;
+    <U>(selector: (state: ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>) => U, equalityFn?: ((a: U, b: U) => boolean) | undefined): U;
+}, InternalProvider: ({ createStore, children, }: {
+    createStore: () => ZustandT.ZustandStore<ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>>;
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>> | undefined>>, useInternalStore: {
+    (): ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>;
+    <U>(selector: (state: ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>) => U, equalityFn?: ((a: U, b: U) => boolean) | undefined): U;
+};
+export declare const config: {
+    defaultProps: DSLeftNavigationTreeT.InternalProps;
+    internalAtomDefaultValues: DSLeftNavigationTreeT.InternalAtoms;
+    useAutoCalculated: () => Record<string, never>;
+    selectors: ZustandT.SelectorObject<DSLeftNavigationTreeT.InternalStore, DSLeftNavigationTreeT.Selectors>;
+    reducers: ZustandT.ReducerObject<DSLeftNavigationTreeT.InternalStore, DSLeftNavigationTreeT.Reducers>;
+    PropsProvider: ({ createStore, children, }: {
+        createStore: () => ZustandT.ZustandStore<ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>>;
+        children: import("react").ReactNode;
+    }) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>> | undefined>>;
+    usePropsStore: {
+        (): ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>;
+        <U>(selector: (state: ZustandT.PropsStore<DSLeftNavigationTreeT.InternalProps & Record<string, never>>) => U, equalityFn?: ((a: U, b: U) => boolean) | undefined): U;
+    };
+    InternalProvider: ({ createStore, children, }: {
+        createStore: () => ZustandT.ZustandStore<ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>>;
+        children: import("react").ReactNode;
+    }) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>> | undefined>>;
+    useInternalStore: {
+        (): ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>;
+        <U>(selector: (state: ZustandT.InternalStore<DSLeftNavigationTreeT.InternalAtoms, DSLeftNavigationTreeT.Selectors, DSLeftNavigationTreeT.Reducers>) => U, equalityFn?: ((a: U, b: U) => boolean) | undefined): U;
+    };
+};

package/dist/types/config/treeModel.d.ts

@@ -0,0 +1,69 @@
+import type { DSLeftNavigationTreeT } from '../react-desc-prop-types.js';
+type Item = DSLeftNavigationTreeT.Item;
+export type TreeNodeInfo = {
+    id: string;
+    item: Item;
+    parentId: string | null;
+    level: number;
+    childIds: string[];
+};
+export type TreeIndex = Map<string, TreeNodeInfo>;
+export type FocusTarget = {
+    kind: 'item';
+    id: string;
+} | {
+    kind: 'footer';
+} | null;
+/**
+ * Root nodes in document order. Children of a root SECTION are root nodes too:
+ * a section is a labelled group, not a tree level.
+ */
+export declare const getRootNodes: (items: readonly Item[]) => Item[];
+export declare const buildTreeIndex: (items: readonly Item[]) => TreeIndex;
+export declare const hasChildren: (info: TreeNodeInfo | undefined) => boolean;
+export declare const isControlledParent: (item: Item) => boolean;
+export declare const getAncestorIds: (index: TreeIndex, id: string | null | undefined) => string[];
+export declare const isDescendantOf: (index: TreeIndex, ancestorId: string, id: string | null | undefined) => boolean;
+export declare const resolveIsOpen: (info: TreeNodeInfo, toggles: Record<string, boolean>, seed: ReadonlySet<string>) => boolean;
+export declare const getVisibleIds: (index: TreeIndex, items: readonly Item[], isOpen: (id: string) => boolean) => string[];
+export declare const getRailIds: (items: readonly Item[]) => string[];
+/** Every node in depth-first document order, regardless of visibility. */
+export declare const getDocumentOrder: (index: TreeIndex, items: readonly Item[]) => string[];
+/**
+ * Default selection when a parent opens (spec "first list item selected by default; if it is a parent folder, it is
+ * expanded by default"): walks the children in order, skips non-selectable leaves, and descends into the first parent
+ * that holds a selectable page, listing the parents that must open on the way.
+ */
+export declare const getDefaultSelection: (index: TreeIndex, parentId: string) => {
+    leafId: string | null;
+    parentIdsToOpen: string[];
+};
+export declare const getTabStopChainId: (index: TreeIndex, visibleIds: string[], currentId: string | null | undefined) => string | null;
+/**
+ * Where focus goes when the focused node stops being visible while focus is inside the tree:
+ * nearest visible ancestor, then the previous visible node in document order, then the first
+ * visible node, then the footer button. A node no longer in the data resolves through the tab-stop chain.
+ */
+export declare const resolveFallbackTarget: ({ index, documentOrder, visibleIds, lostId, currentId, }: {
+    index: TreeIndex;
+    documentOrder: string[];
+    visibleIds: string[];
+    lostId: string;
+    currentId: string | null | undefined;
+}) => FocusTarget;
+export declare const getTypeaheadMatchId: ({ index, visibleIds, fromId, character, }: {
+    index: TreeIndex;
+    visibleIds: string[];
+    fromId: string;
+    character: string;
+}) => string | null;
+export declare const ROW_PADDING = 12;
+/** Parents without an icon show their arrow before the label; parents with an icon show it after the label. */
+export declare const hasLeadingArrow: (info: TreeNodeInfo | undefined) => boolean;
+/**
+ * Left padding per row, following the Left Nav 1.0.4 spec: children of a parent with an icon (a section such as
+ * Forms or Log) start their label 16px after the parent's row padding; children of an arrow-led parent start
+ * 16px after the parent's label. The index lists parents before their children.
+ */
+export declare const getRowPaddings: (index: TreeIndex) => ReadonlyMap<string, number>;
+export {};

package/dist/types/config/useAutoCalculated.d.ts

@@ -0,0 +1 @@
+export declare const useAutoCalculated: () => Record<string, never>;

package/dist/types/config/useFocusTracker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Write side of the focus tracker: named semantic handlers only.
+ * Components read the focus region and item from the store with their own selector,
+ * and apply focus from a ref callback when they are the derived focus target.
+ */
+export declare const useFocusTracker: () => {
+    trackFocusItem: (id: string) => void;
+    trackFocusHeader: () => void;
+    trackFocusFooter: () => void;
+    trackFocusRegionReset: () => void;
+};

package/dist/types/config/useTreeHandlers.d.ts

@@ -0,0 +1,11 @@
+import type React from 'react';
+import type { DSLeftNavigationTreeT } from '../react-desc-prop-types.js';
+import type { TreeModel } from './useTreeModel.js';
+type InteractionEvent = DSLeftNavigationTreeT.InteractionEvent;
+export declare const useTreeHandlers: (model: TreeModel) => {
+    activate: (id: string, e: InteractionEvent) => void;
+    onTreeKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+    onTreeFocus: (e: React.FocusEvent<HTMLElement>) => void;
+    onTreeBlur: (e: React.FocusEvent<HTMLElement>) => void;
+};
+export {};

package/dist/types/config/useTreeModel.d.ts

@@ -0,0 +1,22 @@
+import type { DSLeftNavigationTreeT } from '../react-desc-prop-types.js';
+import { type FocusTarget, type TreeIndex } from './treeModel.js';
+export type TreeModel = {
+    items: readonly DSLeftNavigationTreeT.Item[];
+    index: TreeIndex;
+    isRail: boolean;
+    headerItem: DSLeftNavigationTreeT.Item | undefined;
+    isHeaderOpen: boolean;
+    openIds: ReadonlySet<string>;
+    visibleIds: string[];
+    currentId: string | null;
+    currentLeafId: string | null;
+    selectedParentIds: ReadonlySet<string>;
+    chainTabStopId: string | null;
+    resolveFocusTarget: (focusRegion: string, focusedItemId: string | null) => FocusTarget;
+    rowPaddings: ReadonlyMap<string, number>;
+};
+export declare const useTreeModel: () => TreeModel;
+export type ItemFocusState = 'focus-target' | 'tab-stop' | 'none';
+/** Primitive per-item result: the item re-renders only when its own focus state changes. */
+export declare const useItemFocusState: (model: TreeModel, id: string) => ItemFocusState;
+export declare const useIsFooterFocusTarget: (model: TreeModel) => boolean;

package/dist/types/config/useValidateProps.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationMap } from '@elliemae/ds-props-helpers';
+import { type DSLeftNavigationTreeT } from '../react-desc-prop-types.js';
+export declare const useValidateProps: (props: DSLeftNavigationTreeT.InternalProps, propTypes: ValidationMap<unknown>) => void;

package/dist/types/constants/index.d.ts

@@ -0,0 +1,54 @@
+export declare const DSLeftNavigationTreeName = "DSLeftnavigationtree";
+export declare const LEFT_NAVIGATION_TREE_ITEM_TYPES: {
+    readonly LEAF: "ds-left-nav-tree-item-leaf";
+    readonly PARENT: "ds-left-nav-tree-item-parent";
+    readonly SECTION: "ds-left-nav-tree-item-section";
+    readonly SEPARATOR: "ds-left-nav-tree-item-separator";
+};
+export declare const LEFT_NAVIGATION_TREE_DEFAULT_LABEL = "Primary";
+export declare const LEFT_NAVIGATION_TREE_REGION_FOCUSES: {
+    readonly RESET: "";
+    readonly TREE: "tree";
+    readonly HEADER: "header";
+    readonly FOOTER: "footer";
+};
+export declare const LEFT_NAVIGATION_TREE_SLOTS: {
+    readonly ROOT: "root";
+    readonly TREE: "tree";
+    readonly ITEM: "item";
+    readonly ITEM_ROW: "item-row";
+    readonly ITEM_LABEL: "item-label";
+    readonly LEFT_CONTAINER: "left-container";
+    readonly COLLAPSED_CONTAINER: "collapsed-container";
+    readonly RIGHT_CONTAINER: "right-container";
+    readonly ARROW_CONTAINER: "arrow-container";
+    readonly GROUP: "group";
+    readonly SECTION_CONTAINER: "section-container";
+    readonly SECTION_LABEL: "section-label";
+    readonly ITEM_SEPARATOR: "item-separator";
+    readonly HEADER_DISCLOSURE: "header-disclosure";
+    readonly FOOTER_MENU: "footer-menu";
+    readonly FOOTER_LABEL: "footer-label";
+    readonly FOOTER_SEPARATOR: "footer-separator";
+    readonly FOOTER_MENU_COLLAPSE: "footer-menu-collapse";
+};
+export declare const LEFT_NAVIGATION_TREE_DATA_TESTID: {
+    readonly ROOT: "ds-leftnavigationtree-root";
+    readonly TREE: "ds-leftnavigationtree-tree";
+    readonly ITEM: "ds-leftnavigationtree-item";
+    readonly ITEM_ROW: "ds-leftnavigationtree-item-row";
+    readonly ITEM_LABEL: "ds-leftnavigationtree-item-label";
+    readonly LEFT_CONTAINER: "ds-leftnavigationtree-left-container";
+    readonly COLLAPSED_CONTAINER: "ds-leftnavigationtree-collapsed-container";
+    readonly RIGHT_CONTAINER: "ds-leftnavigationtree-right-container";
+    readonly ARROW_CONTAINER: "ds-leftnavigationtree-arrow-container";
+    readonly GROUP: "ds-leftnavigationtree-group";
+    readonly SECTION_CONTAINER: "ds-leftnavigationtree-section-container";
+    readonly SECTION_LABEL: "ds-leftnavigationtree-section-label";
+    readonly ITEM_SEPARATOR: "ds-leftnavigationtree-item-separator";
+    readonly HEADER_DISCLOSURE: "ds-leftnavigationtree-header-disclosure";
+    readonly FOOTER_MENU: "ds-leftnavigationtree-footer-menu";
+    readonly FOOTER_LABEL: "ds-leftnavigationtree-footer-label";
+    readonly FOOTER_SEPARATOR: "ds-leftnavigationtree-footer-separator";
+    readonly FOOTER_MENU_COLLAPSE: "ds-leftnavigationtree-footer-menu-collapse";
+};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { DSLeftNavigationTree, DSLeftNavigationTreeWithSchema } from './DSLeftNavigationTree.js';
+export { type DSLeftNavigationTreeT, DSLeftNavigationTreeItemSchema, DSLeftNavigationTreeItemOptsSchema, } from './react-desc-prop-types.js';
+export { DSLeftNavigationTreeName, LEFT_NAVIGATION_TREE_ITEM_TYPES, LEFT_NAVIGATION_TREE_REGION_FOCUSES, LEFT_NAVIGATION_TREE_SLOTS, LEFT_NAVIGATION_TREE_DATA_TESTID, } from './constants/index.js';

package/dist/types/parts/Footer.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const Footer: () => React.JSX.Element;

package/dist/types/parts/Header.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const HeaderDisclosure: () => React.JSX.Element | null;

package/dist/types/parts/MainContent.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const MainContent: React.MemoExoticComponent<() => React.JSX.Element>;

package/dist/types/parts/RailItem.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+/**
+ * Collapsed-rail node: an icon-only end treeitem. The label stays in the DOM with display: none
+ * because it is the aria-labelledby target (hidden targets still name the element, and are not read twice).
+ */
+export declare const RailItem: React.MemoExoticComponent<({ id }: {
+    id: string;
+}) => React.JSX.Element | null>;

package/dist/types/parts/TreeContext.d.ts

@@ -0,0 +1,11 @@
+import type { DSLeftNavigationTreeT } from '../react-desc-prop-types.js';
+import type { TreeModel } from '../config/useTreeModel.js';
+import type { useTreeHandlers } from '../config/useTreeHandlers.js';
+export type TreeContextValue = {
+    model: TreeModel;
+    handlers: ReturnType<typeof useTreeHandlers>;
+    getOwnerProps: () => object;
+    labelOverflow: DSLeftNavigationTreeT.LabelOverflowT;
+    getElementId: (kind: string, dsId: string) => string;
+};
+export declare const TreeContext: import("react").Context<TreeContextValue>;

package/dist/types/parts/TreeItem.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const TreeItem: React.MemoExoticComponent<({ id }: {
+    id: string;
+}) => React.JSX.Element | null>;

package/dist/types/parts/TreeRoot.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type NameProps = {
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+};
+export declare const TreeRoot: ({ nameProps }: {
+    nameProps: NameProps;
+}) => React.JSX.Element | null;
+export {};

package/dist/types/parts/styled.d.ts

@@ -0,0 +1,46 @@
+import type { DSLeftNavigationTreeT } from '../react-desc-prop-types.js';
+export declare const StyledRoot: import("styled-components").StyledComponent<"nav", import("@elliemae/ds-system").Theme, {
+    expanded: boolean;
+    expandedWidth: string;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"nav">, never>;
+export declare const StyledTree: import("styled-components").StyledComponent<"ul", import("@elliemae/ds-system").Theme, {
+    isHeaderContent: boolean;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"ul">, never>;
+export declare const StyledGroup: import("styled-components").StyledComponent<"ul", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"ul">, never>;
+export declare const StyledSectionContainer: import("styled-components").StyledComponent<"ul", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"ul">, never>;
+export declare const StyledSectionLabel: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledItemSeparator: import("styled-components").StyledComponent<"div", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"div">, never>;
+/**
+ * The focus ring is drawn on the row of the focused treeitem only: the `li` holds the whole
+ * expanded subtree, so an outline on it would surround every descendant row.
+ */
+export declare const StyledItem: import("styled-components").StyledComponent<"li", import("@elliemae/ds-system").Theme, {
+    isOpenSection: boolean;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"li">, never>;
+export declare const StyledItemRow: import("styled-components").StyledComponent<"div", import("@elliemae/ds-system").Theme, {
+    rowPadding: number;
+    isTall: boolean;
+    isSticky: boolean;
+    isCurrent: boolean;
+    isSelectedParent: boolean;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"div">, never>;
+export declare const StyledItemLabel: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, {
+    isTall: boolean;
+    labelOverflow: DSLeftNavigationTreeT.LabelOverflowT;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledLeftContainer: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledCollapsedContainer: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledRightContainer: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledArrowContainer: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, {
+    isLeading: boolean;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledHeaderDisclosure: import("styled-components").StyledComponent<"button", import("@elliemae/ds-system").Theme, {
+    isRail: boolean;
+    isOpen: boolean;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"button">, never>;
+export declare const StyledFooterMenu: import("styled-components").StyledComponent<"div", import("@elliemae/ds-system").Theme, {
+    expanded: boolean;
+} & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"div">, never>;
+export declare const StyledFooterLabel: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledFooterSeparator: import("styled-components").StyledComponent<"span", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"span">, never>;
+export declare const StyledFooterButton: import("styled-components").StyledComponent<"button", import("@elliemae/ds-system").Theme, object & import("@elliemae/ds-system").OwnerInterface & import("@elliemae/ds-system").InnerRefInterface<"button">, never>;