@elliemae/ds-toolbar-v2 3.22.0-next.30

package/dist/cjs/DSToolbarDefinitions.js

@@ -0,0 +1,38 @@
+"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 DSToolbarDefinitions_exports = {};
+__export(DSToolbarDefinitions_exports, {
+  DSToolbarItemName: () => DSToolbarItemName,
+  DSToolbarName: () => DSToolbarName
+});
+module.exports = __toCommonJS(DSToolbarDefinitions_exports);
+var React = __toESM(require("react"));
+const DSToolbarName = "DSToolbar";
+const DSToolbarItemName = "DSToolbarItem";
+//# sourceMappingURL=DSToolbarDefinitions.js.map

package/dist/cjs/DSToolbarDefinitions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSToolbarDefinitions.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const DSToolbarName = 'DSToolbar';\n\nexport const DSToolbarItemName = 'DSToolbarItem';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,gBAAgB;AAEtB,MAAM,oBAAoB;",
+  "names": []
+}

package/dist/cjs/DSToolbarItemV2.js

@@ -0,0 +1,79 @@
+"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 DSToolbarItemV2_exports = {};
+__export(DSToolbarItemV2_exports, {
+  DSToolbarItemV2: () => DSToolbarItemV2,
+  DSToolbarItemV2WithSchema: () => DSToolbarItemV2WithSchema
+});
+module.exports = __toCommonJS(DSToolbarItemV2_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_uid = require("uid");
+var import_lodash = require("lodash");
+var import_DSToolbarV2Context = require("./DSToolbarV2Context.js");
+var import_styled = require("./styled.js");
+var import_useToolbarItemHandlers = require("./useToolbarItemHandlers.js");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_DSToolbarDefinitions = require("./DSToolbarDefinitions.js");
+const DSToolbarItemV2 = (props) => {
+  const propsWithDefaults = (0, import_ds_props_helpers.useMemoMergePropsWithDefault)(props, import_react_desc_prop_types.defaultItemProps);
+  (0, import_ds_props_helpers.useValidateTypescriptPropTypes)(propsWithDefaults, import_react_desc_prop_types.DSToolbarItemV2Schema, import_DSToolbarDefinitions.DSToolbarItemName);
+  const { render: ComponentRenderer, isFirstItem } = propsWithDefaults;
+  const { id: providedId, ...restGlobals } = (0, import_lodash.omit)((0, import_ds_props_helpers.useGetGlobalAttributes)(propsWithDefaults), ["rows", "cols", "wrap"]);
+  const { registerReference, dndDraggingItem } = (0, import_react.useContext)(import_DSToolbarV2Context.DSToolbarV2Context);
+  const ref = (0, import_react.useRef)(null);
+  const toolbarItemId = (0, import_react.useMemo)(() => {
+    const id = providedId ?? `ds-toolbar-item-${(0, import_uid.uid)()}`;
+    registerReference(id, ref);
+    return id;
+  }, [registerReference, ref, providedId]);
+  const tabIndex = (0, import_react.useMemo)(
+    () => dndDraggingItem === toolbarItemId || !dndDraggingItem && isFirstItem ? 0 : -1,
+    [dndDraggingItem, isFirstItem, toolbarItemId]
+  );
+  const handlers = (0, import_useToolbarItemHandlers.useToolbarItemHandlers)(toolbarItemId);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_styled.StyledToolbarItem,
+    {
+      id: toolbarItemId,
+      "data-testid": "ds-toolbar-item",
+      className: "ds-toolbar-item",
+      ...handlers,
+      ...restGlobals,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ComponentRenderer, { innerRef: ref, tabIndex })
+    }
+  );
+};
+DSToolbarItemV2.propTypes = import_react_desc_prop_types.DSToolbarItemV2Schema;
+DSToolbarItemV2.displayName = import_DSToolbarDefinitions.DSToolbarItemName;
+const DSToolbarItemV2WithSchema = (0, import_ds_props_helpers.describe)(DSToolbarItemV2).description("Toolbar Item");
+DSToolbarItemV2WithSchema.propTypes = import_react_desc_prop_types.DSToolbarItemV2Schema;
+//# sourceMappingURL=DSToolbarItemV2.js.map

package/dist/cjs/DSToolbarItemV2.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSToolbarItemV2.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable react/prop-types */\nimport React, { useContext, useMemo, useRef } from 'react';\nimport {\n  describe,\n  useMemoMergePropsWithDefault,\n  useValidateTypescriptPropTypes,\n  useGetGlobalAttributes,\n} from '@elliemae/ds-props-helpers';\nimport { uid } from 'uid';\nimport { omit } from 'lodash';\nimport { DSToolbarV2Context } from './DSToolbarV2Context.js';\nimport { StyledToolbarItem } from './styled.js';\nimport { useToolbarItemHandlers } from './useToolbarItemHandlers.js';\nimport { defaultItemProps, DSToolbarItemV2Schema } from './react-desc-prop-types.js';\nimport type { DSToolbarItemT } from './react-desc-prop-types.js';\nimport { DSToolbarItemName } from './DSToolbarDefinitions.js';\nconst DSToolbarItemV2: React.ComponentType<DSToolbarItemT.Props> = (props) => {\n  const propsWithDefaults = useMemoMergePropsWithDefault<DSToolbarItemT.Props>(props, defaultItemProps);\n\n  useValidateTypescriptPropTypes(propsWithDefaults, DSToolbarItemV2Schema, DSToolbarItemName);\n  const { render: ComponentRenderer, isFirstItem } = propsWithDefaults;\n  const { id: providedId, ...restGlobals } = omit(useGetGlobalAttributes(propsWithDefaults), ['rows', 'cols', 'wrap']);\n  const { registerReference, dndDraggingItem } = useContext(DSToolbarV2Context);\n  const ref = useRef<DSToolbarItemT.RenderHTMLElementT>(null);\n\n  const toolbarItemId = useMemo(() => {\n    const id = providedId ?? `ds-toolbar-item-${uid()}`;\n    registerReference(id, ref);\n    return id;\n  }, [registerReference, ref, providedId]);\n\n  const tabIndex = useMemo(\n    () => (dndDraggingItem === toolbarItemId || (!dndDraggingItem && isFirstItem) ? 0 : -1),\n    [dndDraggingItem, isFirstItem, toolbarItemId],\n  );\n\n  const handlers = useToolbarItemHandlers(toolbarItemId);\n  return (\n    <StyledToolbarItem\n      id={toolbarItemId}\n      data-testid=\"ds-toolbar-item\"\n      className=\"ds-toolbar-item\"\n      {...handlers}\n      {...restGlobals}\n    >\n      <ComponentRenderer innerRef={ref} tabIndex={tabIndex} />\n    </StyledToolbarItem>\n  );\n};\n\nDSToolbarItemV2.propTypes = DSToolbarItemV2Schema;\n\nDSToolbarItemV2.displayName = DSToolbarItemName;\nconst DSToolbarItemV2WithSchema = describe(DSToolbarItemV2).description('Toolbar Item');\nDSToolbarItemV2WithSchema.propTypes = DSToolbarItemV2Schema;\n\nexport { DSToolbarItemV2, DSToolbarItemV2WithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;AD6CjB;AA5CN,mBAAmD;AACnD,8BAKO;AACP,iBAAoB;AACpB,oBAAqB;AACrB,gCAAmC;AACnC,oBAAkC;AAClC,oCAAuC;AACvC,mCAAwD;AAExD,kCAAkC;AAClC,MAAM,kBAA6D,CAAC,UAAU;AAC5E,QAAM,wBAAoB,sDAAmD,OAAO,6CAAgB;AAEpG,8DAA+B,mBAAmB,oDAAuB,6CAAiB;AAC1F,QAAM,EAAE,QAAQ,mBAAmB,YAAY,IAAI;AACnD,QAAM,EAAE,IAAI,YAAY,GAAG,YAAY,QAAI,wBAAK,gDAAuB,iBAAiB,GAAG,CAAC,QAAQ,QAAQ,MAAM,CAAC;AACnH,QAAM,EAAE,mBAAmB,gBAAgB,QAAI,yBAAW,4CAAkB;AAC5E,QAAM,UAAM,qBAA0C,IAAI;AAE1D,QAAM,oBAAgB,sBAAQ,MAAM;AAClC,UAAM,KAAK,cAAc,uBAAmB,gBAAI;AAChD,sBAAkB,IAAI,GAAG;AACzB,WAAO;AAAA,EACT,GAAG,CAAC,mBAAmB,KAAK,UAAU,CAAC;AAEvC,QAAM,eAAW;AAAA,IACf,MAAO,oBAAoB,iBAAkB,CAAC,mBAAmB,cAAe,IAAI;AAAA,IACpF,CAAC,iBAAiB,aAAa,aAAa;AAAA,EAC9C;AAEA,QAAM,eAAW,sDAAuB,aAAa;AACrD,SACE;AAAA,IAAC;AAAA;AAAA,MACC,IAAI;AAAA,MACJ,eAAY;AAAA,MACZ,WAAU;AAAA,MACT,GAAG;AAAA,MACH,GAAG;AAAA,MAEJ,sDAAC,qBAAkB,UAAU,KAAK,UAAoB;AAAA;AAAA,EACxD;AAEJ;AAEA,gBAAgB,YAAY;AAE5B,gBAAgB,cAAc;AAC9B,MAAM,gCAA4B,kCAAS,eAAe,EAAE,YAAY,cAAc;AACtF,0BAA0B,YAAY;",
+  "names": []
+}

package/dist/cjs/DSToolbarSeparatorV2.js

@@ -0,0 +1,38 @@
+"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 DSToolbarSeparatorV2_exports = {};
+__export(DSToolbarSeparatorV2_exports, {
+  DSToolbarSeparatorV2: () => DSToolbarSeparatorV2
+});
+module.exports = __toCommonJS(DSToolbarSeparatorV2_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_styled = require("./styled.js");
+const DSToolbarSeparatorV2 = () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_styled.StyledSeparator, { className: "ds-toolbar-separator" });
+//# sourceMappingURL=DSToolbarSeparatorV2.js.map

package/dist/cjs/DSToolbarSeparatorV2.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSToolbarSeparatorV2.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\nimport { StyledSeparator } from './styled.js';\n\nexport const DSToolbarSeparatorV2: React.ComponentType = () => <StyledSeparator className=\"ds-toolbar-separator\" />;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADGwC;AAF/D,oBAAgC;AAEzB,MAAM,uBAA4C,MAAM,4CAAC,iCAAgB,WAAU,wBAAuB;",
+  "names": []
+}

package/dist/cjs/DSToolbarV2.js

@@ -0,0 +1,84 @@
+"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 DSToolbarV2_exports = {};
+__export(DSToolbarV2_exports, {
+  DSToolbarV2: () => DSToolbarV2,
+  DSToolbarV2WithSchema: () => DSToolbarV2WithSchema
+});
+module.exports = __toCommonJS(DSToolbarV2_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_uid = require("uid");
+var import_lodash = require("lodash");
+var import_DSToolbarV2Context = require("./DSToolbarV2Context.js");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_styled = require("./styled.js");
+var import_DSToolbarDefinitions = require("./DSToolbarDefinitions.js");
+const DSToolbarV2 = (props) => {
+  const propsWithDefaults = (0, import_ds_props_helpers.useMemoMergePropsWithDefault)(props, import_react_desc_prop_types.defaultProps);
+  (0, import_ds_props_helpers.useValidateTypescriptPropTypes)(propsWithDefaults, import_react_desc_prop_types.DSToolbarV2Schema, import_DSToolbarDefinitions.DSToolbarName);
+  const { alignment, withDepth, compact, innerRef, children } = propsWithDefaults;
+  const globalsProps = (0, import_lodash.omit)((0, import_ds_props_helpers.useGetGlobalAttributes)(propsWithDefaults), ["cols", "rows", "wrap"]);
+  const toolbarUid = (0, import_react.useMemo)(() => globalsProps.id ?? `ds-toolbar-${(0, import_uid.uid)()}`, [globalsProps.id]);
+  const [itemReferences, setItemReferences] = (0, import_react.useState)({});
+  const [dndDraggingItem, setDndDraggingItem] = (0, import_react.useState)("");
+  const registerReference = (0, import_react.useCallback)(
+    (itemId, ref) => {
+      setItemReferences((prevItemReferences) => ({ ...prevItemReferences, [itemId]: ref }));
+    },
+    [setItemReferences]
+  );
+  const ctx = (0, import_react.useMemo)(
+    () => ({ toolbarUid, registerReference, itemReferences, dndDraggingItem, setDndDraggingItem }),
+    [dndDraggingItem, itemReferences, registerReference, toolbarUid]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_DSToolbarV2Context.DSToolbarV2Context.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_styled.StyledToolbarWrapper,
+    {
+      role: "toolbar",
+      "data-testid": "ds-toolbar-wrapper",
+      id: toolbarUid,
+      alignItems: "center",
+      justifyContent: alignment === "left" ? "flex-start" : "flex-end",
+      withDepth,
+      gutter: "xxs2",
+      compact,
+      ref: innerRef,
+      ...globalsProps,
+      children
+    }
+  ) });
+};
+DSToolbarV2.propTypes = import_react_desc_prop_types.DSToolbarV2Schema;
+DSToolbarV2.displayName = import_DSToolbarDefinitions.DSToolbarName;
+const DSToolbarV2WithSchema = (0, import_ds_props_helpers.describe)(DSToolbarV2).description("Toolbar");
+DSToolbarV2WithSchema.propTypes = import_react_desc_prop_types.DSToolbarV2Schema;
+//# sourceMappingURL=DSToolbarV2.js.map

package/dist/cjs/DSToolbarV2.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSToolbarV2.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable react/prop-types */\nimport React, { useCallback, useMemo, useState } from 'react';\nimport {\n  useMemoMergePropsWithDefault,\n  useValidateTypescriptPropTypes,\n  useGetGlobalAttributes,\n  describe,\n} from '@elliemae/ds-props-helpers';\nimport { uid } from 'uid';\nimport { omit } from 'lodash';\nimport { DSToolbarV2Context } from './DSToolbarV2Context.js';\nimport { DSToolbarV2Schema, defaultProps } from './react-desc-prop-types.js';\nimport { StyledToolbarWrapper } from './styled.js';\nimport type { DSToolbarT, DSToolbarItemT } from './react-desc-prop-types.js';\nimport { DSToolbarName } from './DSToolbarDefinitions.js';\nconst DSToolbarV2: React.ComponentType<DSToolbarT.Props> = (props) => {\n  const propsWithDefaults = useMemoMergePropsWithDefault<DSToolbarT.InternalProps>(props, defaultProps);\n\n  useValidateTypescriptPropTypes(propsWithDefaults, DSToolbarV2Schema, DSToolbarName);\n\n  const { alignment, withDepth, compact, innerRef, children } = propsWithDefaults;\n\n  const globalsProps = omit(useGetGlobalAttributes(propsWithDefaults), ['cols', 'rows', 'wrap']);\n\n  const toolbarUid = useMemo(() => globalsProps.id ?? `ds-toolbar-${uid()}`, [globalsProps.id]);\n\n  const [itemReferences, setItemReferences] = useState({});\n  const [dndDraggingItem, setDndDraggingItem] = useState('');\n\n  const registerReference = useCallback(\n    (itemId: string, ref: React.MutableRefObject<DSToolbarItemT.RenderHTMLElementT>) => {\n      setItemReferences((prevItemReferences) => ({ ...prevItemReferences, [itemId]: ref }));\n    },\n    [setItemReferences],\n  );\n\n  const ctx = useMemo(\n    () => ({ toolbarUid, registerReference, itemReferences, dndDraggingItem, setDndDraggingItem }),\n    [dndDraggingItem, itemReferences, registerReference, toolbarUid],\n  );\n\n  return (\n    <DSToolbarV2Context.Provider value={ctx}>\n      <StyledToolbarWrapper\n        role=\"toolbar\"\n        data-testid=\"ds-toolbar-wrapper\"\n        id={toolbarUid}\n        alignItems=\"center\"\n        justifyContent={alignment === 'left' ? 'flex-start' : 'flex-end'}\n        withDepth={withDepth}\n        gutter=\"xxs2\"\n        compact={compact}\n        ref={innerRef}\n        {...globalsProps}\n      >\n        {children}\n      </StyledToolbarWrapper>\n    </DSToolbarV2Context.Provider>\n  );\n};\n\nDSToolbarV2.propTypes = DSToolbarV2Schema;\n\nDSToolbarV2.displayName = DSToolbarName;\nconst DSToolbarV2WithSchema = describe(DSToolbarV2).description('Toolbar');\nDSToolbarV2WithSchema.propTypes = DSToolbarV2Schema;\n\nexport { DSToolbarV2, DSToolbarV2WithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;AD2CjB;AA1CN,mBAAsD;AACtD,8BAKO;AACP,iBAAoB;AACpB,oBAAqB;AACrB,gCAAmC;AACnC,mCAAgD;AAChD,oBAAqC;AAErC,kCAA8B;AAC9B,MAAM,cAAqD,CAAC,UAAU;AACpE,QAAM,wBAAoB,sDAAuD,OAAO,yCAAY;AAEpG,8DAA+B,mBAAmB,gDAAmB,yCAAa;AAElF,QAAM,EAAE,WAAW,WAAW,SAAS,UAAU,SAAS,IAAI;AAE9D,QAAM,mBAAe,wBAAK,gDAAuB,iBAAiB,GAAG,CAAC,QAAQ,QAAQ,MAAM,CAAC;AAE7F,QAAM,iBAAa,sBAAQ,MAAM,aAAa,MAAM,kBAAc,gBAAI,KAAK,CAAC,aAAa,EAAE,CAAC;AAE5F,QAAM,CAAC,gBAAgB,iBAAiB,QAAI,uBAAS,CAAC,CAAC;AACvD,QAAM,CAAC,iBAAiB,kBAAkB,QAAI,uBAAS,EAAE;AAEzD,QAAM,wBAAoB;AAAA,IACxB,CAAC,QAAgB,QAAmE;AAClF,wBAAkB,CAAC,wBAAwB,EAAE,GAAG,oBAAoB,CAAC,MAAM,GAAG,IAAI,EAAE;AAAA,IACtF;AAAA,IACA,CAAC,iBAAiB;AAAA,EACpB;AAEA,QAAM,UAAM;AAAA,IACV,OAAO,EAAE,YAAY,mBAAmB,gBAAgB,iBAAiB,mBAAmB;AAAA,IAC5F,CAAC,iBAAiB,gBAAgB,mBAAmB,UAAU;AAAA,EACjE;AAEA,SACE,4CAAC,6CAAmB,UAAnB,EAA4B,OAAO,KAClC;AAAA,IAAC;AAAA;AAAA,MACC,MAAK;AAAA,MACL,eAAY;AAAA,MACZ,IAAI;AAAA,MACJ,YAAW;AAAA,MACX,gBAAgB,cAAc,SAAS,eAAe;AAAA,MACtD;AAAA,MACA,QAAO;AAAA,MACP;AAAA,MACA,KAAK;AAAA,MACJ,GAAG;AAAA,MAEH;AAAA;AAAA,EACH,GACF;AAEJ;AAEA,YAAY,YAAY;AAExB,YAAY,cAAc;AAC1B,MAAM,4BAAwB,kCAAS,WAAW,EAAE,YAAY,SAAS;AACzE,sBAAsB,YAAY;",
+  "names": []
+}

package/dist/cjs/DSToolbarV2Context.js

@@ -0,0 +1,44 @@
+"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 DSToolbarV2Context_exports = {};
+__export(DSToolbarV2Context_exports, {
+  DSToolbarV2Context: () => DSToolbarV2Context
+});
+module.exports = __toCommonJS(DSToolbarV2Context_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const DSToolbarV2Context = (0, import_react.createContext)({
+  registerReference: () => null,
+  itemReferences: {},
+  toolbarUid: "",
+  dndDraggingItem: "",
+  setDndDraggingItem: () => {
+  }
+});
+//# sourceMappingURL=DSToolbarV2Context.js.map

package/dist/cjs/DSToolbarV2Context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSToolbarV2Context.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { MutableRefObject } from 'react';\nimport { createContext } from 'react';\nimport { type DSToolbarItemT } from './react-desc-prop-types.js';\ninterface IDSToolbarV2Context {\n  registerReference: (uid: string, ref: React.MutableRefObject<DSToolbarItemT.RenderHTMLElementT>) => void;\n  itemReferences: Record<string, MutableRefObject<HTMLElement | null>>;\n  toolbarUid: string;\n  dndDraggingItem: string;\n  setDndDraggingItem: React.Dispatch<React.SetStateAction<string>>;\n}\nexport const DSToolbarV2Context = createContext<IDSToolbarV2Context>({\n  registerReference: () => null,\n  itemReferences: {},\n  toolbarUid: '',\n  dndDraggingItem: '',\n  setDndDraggingItem: () => {},\n});\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAA8B;AASvB,MAAM,yBAAqB,4BAAmC;AAAA,EACnE,mBAAmB,MAAM;AAAA,EACzB,gBAAgB,CAAC;AAAA,EACjB,YAAY;AAAA,EACZ,iBAAiB;AAAA,EACjB,oBAAoB,MAAM;AAAA,EAAC;AAC7B,CAAC;",
+  "names": []
+}

package/dist/cjs/index.js

@@ -0,0 +1,32 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+__reExport(src_exports, require("./DSToolbarV2.js"), module.exports);
+__reExport(src_exports, require("./DSToolbarItemV2.js"), module.exports);
+__reExport(src_exports, require("./DSToolbarSeparatorV2.js"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './DSToolbarV2.js';\nexport * from './DSToolbarItemV2.js';\nexport * from './DSToolbarSeparatorV2.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;ADAvB,wBAAc,6BAAd;AACA,wBAAc,iCADd;AAEA,wBAAc,sCAFd;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/cjs/react-desc-prop-types.js

@@ -0,0 +1,70 @@
+"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 react_desc_prop_types_exports = {};
+__export(react_desc_prop_types_exports, {
+  DSToolbarItemV2PropTypes: () => DSToolbarItemV2PropTypes,
+  DSToolbarItemV2Schema: () => DSToolbarItemV2Schema,
+  DSToolbarPropTypes: () => DSToolbarPropTypes,
+  DSToolbarV2Schema: () => DSToolbarV2Schema,
+  defaultItemProps: () => defaultItemProps,
+  defaultProps: () => defaultProps
+});
+module.exports = __toCommonJS(react_desc_prop_types_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+const defaultItemProps = {
+  render: () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {}),
+  isFirstItem: false
+};
+const defaultProps = {
+  alignment: "right",
+  withDepth: true,
+  compact: false
+};
+const DSToolbarPropTypes = {
+  ...import_ds_props_helpers.xstyledPropTypes,
+  ...import_ds_props_helpers.globalAttributesPropTypes,
+  alignment: import_ds_props_helpers.PropTypes.oneOf(["right", "left"]).description("Whether to align the content left or right").defaultValue("right"),
+  withDepth: import_ds_props_helpers.PropTypes.bool.description("Whether to add a box-shadow to the container").defaultValue(true),
+  compact: import_ds_props_helpers.PropTypes.bool.description("Whether you want the compact version of the toolbar").defaultValue(false),
+  innerRef: import_ds_props_helpers.PropTypes.oneOfType([import_ds_props_helpers.PropTypes.func, import_ds_props_helpers.PropTypes.object]).description("Reference to attach to the wrapper")
+};
+const DSToolbarV2Schema = DSToolbarPropTypes;
+const DSToolbarItemV2PropTypes = {
+  ...import_ds_props_helpers.xstyledPropTypes,
+  ...import_ds_props_helpers.globalAttributesPropTypes,
+  render: import_ds_props_helpers.PropTypes.func.isRequired.description("render function").defaultValue(() => {
+  }),
+  isFirstItem: import_ds_props_helpers.PropTypes.bool.description(
+    "If true the item will have tab index 0 to be the first element focusable by keyboard on the page load"
+  ).defaultValue(false)
+};
+const DSToolbarItemV2Schema = DSToolbarPropTypes;
+//# sourceMappingURL=react-desc-prop-types.js.map

package/dist/cjs/react-desc-prop-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react-desc-prop-types.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import {\n  globalAttributesPropTypes,\n  xstyledPropTypes,\n  PropTypes,\n  type GlobalAttributesT,\n  type XstyledProps,\n  type DSPropTypesSchema,\n} from '@elliemae/ds-props-helpers';\nimport { type WeakValidationMap } from 'react';\n\nexport declare namespace DSToolbarT {\n  export interface DefaultProps {\n    alignment: 'left' | 'right';\n    withDepth: boolean;\n    compact: boolean;\n  }\n\n  export interface OptionalProps {\n    innerRef?: React.MutableRefObject<HTMLDivElement>;\n    children?: React.ReactNode;\n  }\n\n  export interface Props\n    extends Partial<DefaultProps>,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof OptionalProps>,\n      XstyledProps {}\n  export interface InternalProps\n    extends DefaultProps,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof OptionalProps>,\n      XstyledProps {}\n}\n\nexport declare namespace DSToolbarItemT {\n  export type RenderHTMLElementT =\n    | HTMLElement\n    | HTMLButtonElement\n    | HTMLInputElement\n    | HTMLTextAreaElement\n    | HTMLSelectElement\n    | HTMLOptionElement\n    | null;\n\n  export interface Props {\n    render: <T>(props: { innerRef: React.MutableRefObject<T>; tabIndex: number }) => JSX.Element;\n    isFirstItem?: boolean;\n  }\n}\n\nexport const defaultItemProps: DSToolbarItemT.Props = {\n  render: () => <></>,\n  isFirstItem: false,\n};\n\nexport const defaultProps: DSToolbarT.DefaultProps = {\n  alignment: 'right',\n  withDepth: true,\n  compact: false,\n};\n\nexport const DSToolbarPropTypes: DSPropTypesSchema<DSToolbarT.Props> = {\n  ...xstyledPropTypes,\n  ...globalAttributesPropTypes,\n  alignment: PropTypes.oneOf(['right', 'left'])\n    .description('Whether to align the content left or right')\n    .defaultValue('right'),\n  withDepth: PropTypes.bool.description('Whether to add a box-shadow to the container').defaultValue(true),\n  compact: PropTypes.bool.description('Whether you want the compact version of the toolbar').defaultValue(false),\n  innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).description('Reference to attach to the wrapper'),\n};\n\nexport const DSToolbarV2Schema = DSToolbarPropTypes as unknown as WeakValidationMap<DSToolbarT.Props>;\n\nexport const DSToolbarItemV2PropTypes = {\n  ...xstyledPropTypes,\n  ...globalAttributesPropTypes,\n  render: PropTypes.func.isRequired.description('render function').defaultValue(() => {}),\n  isFirstItem: PropTypes.bool\n    .description(\n      'If true the item will have tab index 0 to be the first element focusable by keyboard on the page load',\n    )\n    .defaultValue(false),\n};\n\nexport const DSToolbarItemV2Schema = DSToolbarPropTypes as unknown as WeakValidationMap<DSToolbarItemT.Props>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADmDP;AAnDhB,8BAOO;AA2CA,MAAM,mBAAyC;AAAA,EACpD,QAAQ,MAAM,2EAAE;AAAA,EAChB,aAAa;AACf;AAEO,MAAM,eAAwC;AAAA,EACnD,WAAW;AAAA,EACX,WAAW;AAAA,EACX,SAAS;AACX;AAEO,MAAM,qBAA0D;AAAA,EACrE,GAAG;AAAA,EACH,GAAG;AAAA,EACH,WAAW,kCAAU,MAAM,CAAC,SAAS,MAAM,CAAC,EACzC,YAAY,4CAA4C,EACxD,aAAa,OAAO;AAAA,EACvB,WAAW,kCAAU,KAAK,YAAY,8CAA8C,EAAE,aAAa,IAAI;AAAA,EACvG,SAAS,kCAAU,KAAK,YAAY,qDAAqD,EAAE,aAAa,KAAK;AAAA,EAC7G,UAAU,kCAAU,UAAU,CAAC,kCAAU,MAAM,kCAAU,MAAM,CAAC,EAAE,YAAY,oCAAoC;AACpH;AAEO,MAAM,oBAAoB;AAE1B,MAAM,2BAA2B;AAAA,EACtC,GAAG;AAAA,EACH,GAAG;AAAA,EACH,QAAQ,kCAAU,KAAK,WAAW,YAAY,iBAAiB,EAAE,aAAa,MAAM;AAAA,EAAC,CAAC;AAAA,EACtF,aAAa,kCAAU,KACpB;AAAA,IACC;AAAA,EACF,EACC,aAAa,KAAK;AACvB;AAEO,MAAM,wBAAwB;",
+  "names": []
+}

package/dist/cjs/styled.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 styled_exports = {};
+__export(styled_exports, {
+  StyledSeparator: () => StyledSeparator,
+  StyledToolbarItem: () => StyledToolbarItem,
+  StyledToolbarWrapper: () => StyledToolbarWrapper
+});
+module.exports = __toCommonJS(styled_exports);
+var React = __toESM(require("react"));
+var import_ds_system = require("@elliemae/ds-system");
+var import_ds_grid = __toESM(require("@elliemae/ds-grid"));
+const StyledToolbarWrapper = (0, import_ds_system.styled)(import_ds_grid.default)`
+  background-color: ${(props) => props.theme.colors.neutral["000"]};
+
+  min-height: ${(props) => props.compact ? "28px" : "36px"};
+  max-height: ${(props) => props.theme.space.xxl};
+
+  padding: 0 ${(props) => props.theme.space.xxs};
+  grid-auto-flow: column;
+  box-shadow: ${(props) => !props.withDepth ? "none" : "0 1px 5px 0 rgb(0 0 0 / 13%), 0 2px 4px 0 rgb(0 0 0 / 20%)"};
+`;
+const StyledToolbarItem = (0, import_ds_system.styled)(import_ds_grid.default)``;
+const StyledSeparator = (0, import_ds_system.styled)(import_ds_grid.default)`
+  height: 30px;
+  width: 1px;
+  background-color: ${(props) => props.theme.colors.neutral[200]};
+`;
+//# sourceMappingURL=styled.js.map

package/dist/cjs/styled.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/styled.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { styled } from '@elliemae/ds-system';\nimport Grid from '@elliemae/ds-grid';\n\nexport const StyledToolbarWrapper = styled(Grid)<{ compact: boolean; withDepth: boolean }>`\n  background-color: ${(props) => props.theme.colors.neutral['000']};\n\n  min-height: ${(props) => (props.compact ? '28px' : '36px')};\n  max-height: ${(props) => props.theme.space.xxl};\n\n  padding: 0 ${(props) => props.theme.space.xxs};\n  grid-auto-flow: column;\n  box-shadow: ${(props) => (!props.withDepth ? 'none' : '0 1px 5px 0 rgb(0 0 0 / 13%), 0 2px 4px 0 rgb(0 0 0 / 20%)')};\n`;\n\nexport const StyledToolbarItem = styled(Grid)``;\n\nexport const StyledSeparator = styled(Grid)`\n  height: 30px;\n  width: 1px;\n  background-color: ${(props) => props.theme.colors.neutral[200]};\n`;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,uBAAuB;AACvB,qBAAiB;AAEV,MAAM,2BAAuB,yBAAO,eAAAA,OAAI;AAAA,sBACzB,CAAC,UAAU,MAAM,MAAM,OAAO,QAAQ,KAAK;AAAA;AAAA,gBAEjD,CAAC,UAAW,MAAM,UAAU,SAAS;AAAA,gBACrC,CAAC,UAAU,MAAM,MAAM,MAAM;AAAA;AAAA,eAE9B,CAAC,UAAU,MAAM,MAAM,MAAM;AAAA;AAAA,gBAE5B,CAAC,UAAW,CAAC,MAAM,YAAY,SAAS;AAAA;AAGjD,MAAM,wBAAoB,yBAAO,eAAAA,OAAI;AAErC,MAAM,sBAAkB,yBAAO,eAAAA,OAAI;AAAA;AAAA;AAAA,sBAGpB,CAAC,UAAU,MAAM,MAAM,OAAO,QAAQ,GAAG;AAAA;",
+  "names": ["Grid"]
+}

package/dist/cjs/useToolbarItemHandlers.js

@@ -0,0 +1,82 @@
+"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 useToolbarItemHandlers_exports = {};
+__export(useToolbarItemHandlers_exports, {
+  useToolbarItemHandlers: () => useToolbarItemHandlers
+});
+module.exports = __toCommonJS(useToolbarItemHandlers_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_DSToolbarV2Context = require("./DSToolbarV2Context.js");
+const findInCircularList = (list, from, criteria, step = 1) => {
+  for (let i = (from + step + list.length) % list.length; i !== from && from > -1; i = (i + step + list.length) % list.length) {
+    if (criteria(list[i]))
+      return i;
+  }
+  return from;
+};
+const useToolbarItemHandlers = (toolbarItemId) => {
+  const { toolbarUid, itemReferences, setDndDraggingItem } = (0, import_react.useContext)(import_DSToolbarV2Context.DSToolbarV2Context);
+  const onFocus = (0, import_react.useCallback)(() => {
+    setDndDraggingItem(toolbarItemId);
+  }, [setDndDraggingItem, toolbarItemId]);
+  const onKeyDown = (0, import_react.useCallback)(
+    (e) => {
+      const toolbarItems = [...document.querySelectorAll(`#${toolbarUid} .ds-toolbar-item`)];
+      let nextToolbarItemIndex = -1;
+      const toolbarItemIndex = toolbarItems.findIndex((domElem) => domElem.id === toolbarItemId);
+      const criteria = (item) => {
+        const ref = itemReferences[item.id];
+        return !ref.current?.getAttribute("disabled");
+      };
+      if (["ArrowLeft", "ArrowRight"].includes(e.code)) {
+        nextToolbarItemIndex = findInCircularList(
+          toolbarItems,
+          toolbarItemIndex,
+          criteria,
+          e.code === "ArrowLeft" ? -1 : 1
+        );
+      } else if (e.code === "Home") {
+        nextToolbarItemIndex = 0;
+      } else if (e.code === "End") {
+        nextToolbarItemIndex = toolbarItems.length - 1;
+      }
+      if (nextToolbarItemIndex >= 0 && nextToolbarItemIndex < toolbarItems.length) {
+        e.preventDefault();
+        e.stopPropagation();
+        const ref = itemReferences[toolbarItems[nextToolbarItemIndex].id];
+        if (ref.current)
+          ref.current.focus();
+      }
+    },
+    [toolbarUid, toolbarItemId, itemReferences]
+  );
+  return { onKeyDown, onFocus };
+};
+//# sourceMappingURL=useToolbarItemHandlers.js.map