@atlaskit/navigation-system 0.166.0

package/dist/cjs/ui/top-nav-items/themed/search.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.themedSearchBorderFocused = exports.themedSearchBorder = void 0;
+exports.useLegacySearchTheme = useLegacySearchTheme;
+var _button = require("./button");
+var _hasCustomThemeContext = require("./has-custom-theme-context");
+var themedSearchBorder = exports.themedSearchBorder = '--ds-top-bar-search-border';
+var themedSearchBorderFocused = exports.themedSearchBorderFocused = '--ds-top-bar-search-border-focused';
+
+/**
+ * Theme object intended for use with Search Platform components while transitioning to nav4.
+ *
+ * This is for backwards compatibility with the legacy theming API that was designed for nav3.
+ *
+ * As nav4 matures we will ideally evolve the theming solution inside Search Platform,
+ * at which point this legacy theme object will not be needed.
+ */
+var legacySearchTheme = {
+  default: {
+    backgroundColor: 'transparent',
+    color: 'currentColor',
+    borderColor: "var(".concat(themedSearchBorder, ")")
+  },
+  focus: {
+    /**
+     * When expanded the input ignores the custom theme,
+     * except for its border which is derived from the highlight color.
+     */
+    color: "var(--ds-text, #172B4D)",
+    backgroundColor: "var(--ds-background-input-pressed, #FFFFFF)",
+    borderColor: "var(".concat(themedSearchBorderFocused, ")"),
+    boxShadow: "inset 0px 0px 0px 1px var(".concat(themedSearchBorderFocused, ")")
+  },
+  hover: {
+    /**
+     * This is not actually used for the search bar input (at least by the Search Platform components).
+     *
+     * Instead it's used as the hover background color for a close button when on mobile.
+     */
+    backgroundColor: "var(".concat(_button.themedButtonBackgroundHovered, ")")
+  }
+};
+
+/**
+ * We are just using the inferred type instead of declaring it as `SearchCSS` (the type `@atlassian/search-dialog` expects)
+ *
+ * Importing the type from `@atlassian/search-dialog` means we have to declare it as a full dependency,
+ * rather than a dev dependency. Even though it's type-only, this is how local consumption is setup.
+ *
+ * This was failing typechecking in Post Office, presumably due to different versions of `@emotion/styled`.
+ * It is also a code smell having an unnecessary dependency.
+ *
+ * We still have indirect type safety from our example + product integrations, so a PR that breaks the types won't be able to merge.
+ */
+
+/**
+ * Provides the `theme` value for Search Platform components.
+ *
+ * This may be a `SearchCSS` object or undefined,
+ * depending on if the top bar is using custom theming.
+ */
+function useLegacySearchTheme() {
+  var hasCustomTheme = (0, _hasCustomThemeContext.useHasCustomTheme)();
+  if (hasCustomTheme) {
+    return legacySearchTheme;
+  }
+  return undefined;
+}

package/dist/cjs/ui/top-nav-items/themed/use-custom-theme.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCustomTheme = useCustomTheme;
+var _react = require("react");
+var _getCustomThemeStyles = require("./get-custom-theme-styles");
+/**
+ * Processes the provided theme and returns theme styles if possible.
+ */
+function useCustomTheme(theme) {
+  var value = (0, _react.useMemo)(function () {
+    if (!(theme !== null && theme !== void 0 && theme.backgroundColor) || !(theme !== null && theme !== void 0 && theme.highlightColor)) {
+      return {
+        isEnabled: false
+      };
+    }
+
+    /**
+     * Re-creating the `theme` object from it's pieces.
+     *
+     * _Technically_ we could just use `theme`, but that would involve an eslint opt out
+     * as we would be leveraging a value (`theme`) not in the dependency array.
+     *
+     * The current approach is the most correct™️ and avoids foot guns.
+     * We are only using values in the effect that are defined in the dependency array 🙌
+     */
+    var value = {
+      backgroundColor: theme.backgroundColor,
+      highlightColor: theme.highlightColor
+    };
+    var style = (0, _getCustomThemeStyles.getCustomThemeStyles)(value);
+    if (!style) {
+      // Either the `backgroundColor` or `highlightColor` could not be parsed
+      return {
+        isEnabled: false
+      };
+    }
+    return {
+      isEnabled: true,
+      style: style
+    };
+  },
+  // Using individual properties as keys for improved memoization.
+  // Now this effect will only run if the values change rather than
+  // the reference to the object (which might be new on every call)
+  [theme === null || theme === void 0 ? void 0 : theme.backgroundColor, theme === null || theme === void 0 ? void 0 : theme.highlightColor]);
+  return value;
+}

package/dist/es2019/components/badge-container.compiled.css

@@ -0,0 +1,7 @@
+._152tr5cr{inset-block-start:var(--ds-space-negative-050,-4px)}
+._1e02utpp{inset-inline-start:var(--ds-space-150,9pt)}
+._1e0c1txw{display:flex}
+._kqswh2mm{position:relative}
+._kqswstnw{position:absolute}
+._lcxvglyw{pointer-events:none}
+._o5721q9c{white-space:nowrap}

package/dist/es2019/components/badge-container.js

@@ -0,0 +1,27 @@
+/* badge-container.tsx generated by @compiled/babel-plugin v0.36.1 */
+import "./badge-container.compiled.css";
+import * as React from 'react';
+import { ax, ix } from "@compiled/react/runtime";
+const styles = {
+  root: "_kqswh2mm _1e0c1txw",
+  badgeContainer: "_kqswstnw _o5721q9c _152tr5cr _1e02utpp _lcxvglyw"
+};
+/**
+ * __Badge container__
+ *
+ * Adds a badge to the top right corner of the child element.
+ * Example of usage is showing the number of notifications in the top navigation bar.
+ */
+export const BadgeContainer = ({
+  children,
+  id: badgeId,
+  badge: Badge,
+  isListItem = true
+}) => /*#__PURE__*/React.createElement("div", {
+  role: isListItem ? 'listitem' : undefined,
+  className: ax([styles.root])
+}, children, /*#__PURE__*/React.createElement("div", {
+  id: badgeId,
+  "aria-hidden": true,
+  className: ax([styles.badgeContainer])
+}, /*#__PURE__*/React.createElement(Badge, null)));

package/dist/es2019/components/forward-ref-with-generic.js

@@ -0,0 +1,6 @@
+import { forwardRef } from 'react';
+
+/**
+ * An alias for `forwardRef` with enhanced typing to preserve generic prop types.
+ */
+export const forwardRefWithGeneric = forwardRef;

package/dist/es2019/components/list-item.js

@@ -0,0 +1,23 @@
+/* list-item.tsx generated by @compiled/babel-plugin v0.36.1 */
+import * as React from 'react';
+import { ax, ix } from "@compiled/react/runtime";
+import { forwardRef } from 'react';
+function _ListItem({
+  children,
+  testId,
+  xcss
+}, ref) {
+  return /*#__PURE__*/React.createElement("div", {
+    role: "listitem",
+    ref: ref,
+    className: xcss,
+    "data-testid": testId
+  }, children);
+}
+
+/**
+ * __List item__
+ *
+ * A [list item](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/li) with visual styles removed.
+ */
+export const ListItem = /*#__PURE__*/forwardRef(_ListItem);

package/dist/es2019/components/list.js

@@ -0,0 +1,33 @@
+/* list.tsx generated by @compiled/babel-plugin v0.36.1 */
+import * as React from 'react';
+import { ax, ix } from "@compiled/react/runtime";
+import { forwardRef } from 'react';
+function _List({
+  children,
+  testId,
+  xcss
+}, forwardedRef) {
+  return (
+    /*#__PURE__*/
+    /**
+     * We are using `role="list"` instead of a `ul` element to enable more flexible
+     * composition. By using ARIA roles we can validly have elements between a list
+     * and list items, as long as those in-between elements have no semantics.
+     */
+    React.createElement("div", {
+      role: "list",
+      ref: forwardedRef,
+      className: xcss,
+      "data-testid": testId
+    }, children)
+  );
+}
+
+/**
+ * __List__
+ *
+ * A an element with the role of `list` for semantically grouping list items.
+ *
+ * This is the internal primitive used by other external components in the navigation system.
+ */
+export const List = /*#__PURE__*/forwardRef(_List);

package/dist/es2019/components/skip-links/skip-link.compiled.css

@@ -0,0 +1 @@
+._1pfhze3t{margin-block-start:var(--ds-space-0,0)}

package/dist/es2019/components/skip-links/skip-link.js

@@ -0,0 +1,114 @@
+/* skip-link.tsx generated by @compiled/babel-plugin v0.36.1 */
+import "./skip-link.compiled.css";
+import { ax, ix } from "@compiled/react/runtime";
+import React, { useCallback } from 'react';
+import { bind } from 'bind-event-listener';
+import { Anchor } from '@atlaskit/primitives';
+const styles = {
+  skipLinkListItem: "_1pfhze3t"
+};
+
+/**
+ * Used for moving focus to the corresponding slot or custom target after clicking on a skip link.
+ */
+function focusElement(element) {
+  /**
+   * Elements without an explicit `tabindex` attribute are not guaranteed to be focusable:
+   * https://html.spec.whatwg.org/multipage/interaction.html#attr-tabindex
+   *
+   * Our slots are not interactive, so this is required.
+   *
+   * In the future we may want to check if there is an existing `tabindex` attribute,
+   * as custom skip linked elements might already have one.
+   */
+  element.setAttribute('tabindex', '-1');
+
+  /**
+   * Cleanup the `tabindex` attribute we set when the slot or custom target loses focus.
+   *
+   * This is preferable to always having `tabindex="-1"` because always applying the tab index can:
+   *
+   * - mess with click events
+   * - potentially cause a focus ring to be always visible
+   */
+  bind(element, {
+    type: 'blur',
+    listener() {
+      element.removeAttribute('tabindex');
+    },
+    options: {
+      // Using a one-time listener so it cleans itself up
+      once: true
+    }
+  });
+
+  /**
+   * Move focus to the slot or custom target.
+   *
+   * Calling `.focus()` will also scroll the element into view:
+   * https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus
+   */
+  element.focus({
+    // Forces the focus ring to appear after moving focus to the slot
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#focusvisible
+    // @ts-expect-error - new and not in types yet
+    focusVisible: true
+  });
+}
+
+/**
+ * A link that moves current tab position to a different element
+ *
+ * This component is rendered internally and is not exported publicly.
+ */
+export const SkipLink = ({
+  id,
+  children,
+  onBeforeNavigate
+}) => {
+  const href = `#${id}`;
+  const onClick = useCallback(event => {
+    event.preventDefault();
+
+    // Intentionally not using `document.querySelector` because many valid IDs are not valid selectors.
+    const target = document.getElementById(id);
+    if (!target) {
+      return;
+    }
+
+    /**
+     * Internal slots can attach an `onBeforeNavigate` callback.
+     *
+     * Side nav uses this to ensure it is expanded.
+     */
+    onBeforeNavigate === null || onBeforeNavigate === void 0 ? void 0 : onBeforeNavigate();
+    focusElement(target);
+
+    /**
+     * We should look into removing this, or only calling it in specific cases.
+     *
+     * It means if the skip link element is in the window scroll container
+     * then it might not get scrolled into view properly.
+     *
+     * This is not an issue for the default slots on desktop, but could break custom skip links or
+     * even `Aside` on mobile.
+     *
+     * Keeping existing behavior for now because resetting the window scroll is actually good for some cases.
+     * E.g. jumping to main / aside it makes sense to look at the start of the content.
+     */
+    window.scrollTo(0, 0);
+  }, [id, onBeforeNavigate]);
+  return /*#__PURE__*/React.createElement("li", {
+    className: ax([styles.skipLinkListItem])
+  }, /*#__PURE__*/React.createElement(Anchor
+  /**
+   * It looks like Safari handles link clicks during `pointerdown` unless it has an explicit `tabIndex={0}` :/
+   *
+   * Adding this explicitly makes the behavior consistent between browsers and lets us `event.preventDefault()`
+   * in the `onClick` handler.
+   */, {
+    tabIndex: 0,
+    href: href,
+    onClick: onClick
+  }, children));
+};

package/dist/es2019/components/skip-links/skip-links-container.compiled.css

@@ -0,0 +1,21 @@
+
+._2rkoglpi{border-radius:var(--ds-border-radius,4px)}
+._zulp1b66{gap:var(--ds-space-050,4px)}
+._18zrutpp{padding-inline:var(--ds-space-150,9pt)}
+._1rjcutpp{padding-block:var(--ds-space-150,9pt)}._152tv47k{inset-block-start:var(--ds-space-250,20px)}
+._16qs1cd0{box-shadow:var(--ds-shadow-overlay,0 8px 9pt #091e4226,0 0 1px #091e424f)}
+._1e02v47k{inset-inline-start:var(--ds-space-250,20px)}
+._1e0c1txw{display:flex}
+._1pby1mrw{z-index:-1}
+._1pfhze3t{margin-block-start:var(--ds-space-0,0)}
+._1x8w11lx{list-style-position:outside}
+._2lx21bp4{flex-direction:column}
+._2mzuglyw{list-style-type:none}
+._bfhk1bhr{background-color:var(--ds-surface-overlay,#fff)}
+._bozgze3t{padding-inline-start:var(--ds-space-0,0)}
+._kqsw1n9t{position:fixed}
+._lcxvglyw{pointer-events:none}
+._tzy4idpf{opacity:0}
+._18eu1wug:focus-within{pointer-events:auto}
+._1digjh3g:focus-within{z-index:calc(infinity)}
+._1mygkb7n:focus-within{opacity:1}

package/dist/es2019/components/skip-links/skip-links-container.js

@@ -0,0 +1,66 @@
+/* skip-links-container.tsx generated by @compiled/babel-plugin v0.36.1 */
+import "./skip-links-container.compiled.css";
+import * as React from 'react';
+import { ax, ix } from "@compiled/react/runtime";
+import { Text } from '@atlaskit/primitives';
+import { useSortedSkipLinks } from '../../context/skip-links/skip-links-data-context';
+import { SkipLink } from './skip-link';
+const styles = {
+  root: "_zulp1b66 _2rkoglpi _1rjcutpp _18zrutpp _1e0c1txw _2lx21bp4 _kqsw1n9t _1e02v47k _152tv47k _bfhk1bhr _16qs1cd0 _1pby1mrw _tzy4idpf _lcxvglyw _1digjh3g _1mygkb7n _18eu1wug",
+  skipLinkList: "_zulp1b66 _1e0c1txw _2lx21bp4 _1x8w11lx _2mzuglyw _1pfhze3t _bozgze3t"
+};
+
+/**
+ * Keydown handler to hide the skip links when escape is pressed.
+ *
+ * TODO: consider removing this, it doesn't make a lot of sense.
+ * The skip links look like a popup but in reality they aren't.
+ * Even though we hide them if you press TAB it will reopen the list and move to the next one...
+ */
+const closeOnEscape = event => {
+  if (event.key !== 'Escape') {
+    return;
+  }
+  const activeElement = document.activeElement;
+  if (activeElement instanceof HTMLElement) {
+    activeElement.blur();
+  }
+};
+const isOnlyWhitespaceRegex = /^\s*$/;
+
+/**
+ * A container element for the skip links
+ * The default label will be used when the `skipLinksLabel` attribute is not
+ * provided or the attribute is an empty string. If a string comprised only of
+ * spaces is provided, the skip link heading element will be removed, but the
+ * default label will still be used in `title` attribute of the skip links
+ * themselves.
+ */
+export const SkipLinksContainer = ({
+  label,
+  testId
+}) => {
+  const sortedSkipLinks = useSortedSkipLinks();
+  if (sortedSkipLinks.length === 0) {
+    return null;
+  }
+  const isEmptyLabel = isOnlyWhitespaceRegex.test(label);
+  return /*#__PURE__*/React.createElement("div", {
+    onKeyDown: closeOnEscape,
+    "data-testid": testId ? `${testId}--skip-links-container` : undefined,
+    className: ax([styles.root])
+  }, !isEmptyLabel && /*#__PURE__*/React.createElement(Text, {
+    weight: "bold",
+    testId: testId ? `${testId}--skip-links-container--label` : undefined
+  }, label), /*#__PURE__*/React.createElement("ol", {
+    className: ax([styles.skipLinkList])
+  }, sortedSkipLinks.map(({
+    id,
+    label,
+    onBeforeNavigate
+  }) => /*#__PURE__*/React.createElement(SkipLink, {
+    key: id,
+    id: id,
+    onBeforeNavigate: onBeforeNavigate
+  }, label))));
+};

package/dist/es2019/context/skip-links/skip-links-context.js

@@ -0,0 +1,61 @@
+import { createContext, useContext, useEffect } from 'react';
+import noop from '@atlaskit/ds-lib/noop';
+/**
+ * Provides a way to register and unregister skip links
+ */
+export const SkipLinksContext = /*#__PURE__*/createContext({
+  registerSkipLink: noop,
+  unregisterSkipLink: noop
+});
+const useSkipLinks = () => useContext(SkipLinksContext);
+
+/**
+ * Internal-only hook for registering skip links.
+ *
+ * `useSkipLink` is the public API wrapper of this.
+ *
+ * This private version exists for us to support `onBeforeNavigate` for the side nav use case,
+ * where we might need to expand it before moving focus, without having to support `onBeforeNavigate` publicly.
+ */
+export const useSkipLinkInternal = ({
+  id,
+  label,
+  listIndex,
+  onBeforeNavigate,
+  isHidden
+}) => {
+  const {
+    registerSkipLink,
+    unregisterSkipLink
+  } = useSkipLinks();
+  useEffect(() => {
+    if (isHidden) {
+      /**
+       * Skip links are hidden for slots with 0 height or width.
+       * They should not be registered.
+       */
+      return;
+    }
+    registerSkipLink({
+      id,
+      label,
+      listIndex,
+      onBeforeNavigate,
+      isHidden
+    });
+    return () => {
+      unregisterSkipLink(id);
+    };
+  }, [id, isHidden, label, listIndex, onBeforeNavigate, registerSkipLink, unregisterSkipLink]);
+};
+
+/**
+ * Call `useSkipLink` to register a skip link for important elements on the page.
+ */
+export const useSkipLink = (id, label, listIndex) => {
+  useSkipLinkInternal({
+    id,
+    label,
+    listIndex
+  });
+};

package/dist/es2019/context/skip-links/skip-links-data-context.js

@@ -0,0 +1,33 @@
+import { createContext, useContext, useMemo } from 'react';
+/**
+ * Provides a way to store skip links
+ */
+export const SkipLinksDataContext = /*#__PURE__*/createContext([]);
+const assignIndex = (num, arr) => {
+  if (!arr.includes(num)) {
+    return num;
+  }
+  return assignIndex(num + 1, arr);
+};
+const sortSkipLinks = arr => {
+  const customLinks = arr.filter(link => Number.isInteger(link.listIndex));
+  if (customLinks.length === 0) {
+    return arr;
+  }
+  const usedIndexes = customLinks.map(a => a.listIndex);
+  const regularLinksWithIdx = arr.filter(link => link.listIndex === undefined).map((link, idx) => {
+    const listIndex = assignIndex(idx, usedIndexes);
+    usedIndexes.push(listIndex);
+    return {
+      ...link,
+      listIndex
+    };
+  });
+  return [...customLinks, ...regularLinksWithIdx].sort((a, b) => a.listIndex - b.listIndex);
+};
+export const useSortedSkipLinks = () => {
+  const skipLinksData = useContext(SkipLinksDataContext);
+  return useMemo(() => {
+    return sortSkipLinks(skipLinksData);
+  }, [skipLinksData]);
+};

package/dist/es2019/context/skip-links/skip-links-provider.js

@@ -0,0 +1,70 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import { SkipLinksContext } from './skip-links-context';
+import { SkipLinksDataContext } from './skip-links-data-context';
+const getByDomOrderSortFunction = () => {
+  const layoutSlots = Array.from(document.querySelectorAll(`[data-layout-slot]`));
+  return (a, b) => {
+    var _a$listIndex, _b$listIndex;
+    const indexA = (_a$listIndex = a.listIndex) !== null && _a$listIndex !== void 0 ? _a$listIndex : layoutSlots.indexOf(document.getElementById(a.id));
+    const indexB = (_b$listIndex = b.listIndex) !== null && _b$listIndex !== void 0 ? _b$listIndex : layoutSlots.indexOf(document.getElementById(b.id));
+
+    /**
+     * If they are tied it is because one (or both) is
+     * a custom skiplink with a set index.
+     *
+     * Give the custom skiplink priority.
+     */
+    if (indexA === indexB) {
+      if (a.listIndex !== undefined) {
+        return -1;
+      } else {
+        return 1;
+      }
+    }
+    return indexA - indexB;
+  };
+};
+
+/**
+ * Provides a way to store and use skip links by combining SkipLinksContext and SkipLinksDataContext
+ */
+export const SkipLinksProvider = ({
+  children
+}) => {
+  const [links, setLinks] = useState([]);
+  const registerSkipLink = useCallback(skipLinkData => {
+    // Don't add duplicate skip links
+    setLinks(oldLinks => {
+      if (oldLinks.some(({
+        id
+      }) => id === skipLinkData.id)) {
+        if (process.env.NODE_ENV !== 'production') {
+          // eslint-disable-next-line no-console
+          console.warn(`\
+Tried registering duplicate skip link for ID '${skipLinkData.id}'.
+
+If you're trying to override a slot skip link label, then use the \`skipLinkLabel\` prop instead.
+
+This error will not be shown in production, and the duplicate skip link will be ignored.`);
+        }
+        return oldLinks;
+      }
+      return [...oldLinks, skipLinkData].sort(getByDomOrderSortFunction());
+    });
+  }, []);
+  const unregisterSkipLink = useCallback(id => {
+    setLinks(links => links.filter(link => link.id !== id));
+  }, []);
+  const contextValue = useMemo(() => {
+    const data = {
+      registerSkipLink,
+      unregisterSkipLink
+    };
+    return data;
+  }, [registerSkipLink, unregisterSkipLink]);
+  return /*#__PURE__*/React.createElement(SkipLinksContext.Provider, {
+    value: contextValue
+  }, /*#__PURE__*/React.createElement(SkipLinksDataContext.Provider, {
+    value: links
+  }, children));
+};

package/dist/es2019/context/top-nav-start/top-nav-start-context-provider.js

@@ -0,0 +1,26 @@
+import React, { useState } from 'react';
+import { TopNavStartAttachRef, TopNavStartElement } from './top-nav-start-context';
+
+/**
+ * Provider for the TopNavStart container element contexts.
+ *
+ * We are using a [ref callback](https://react.dev/reference/react-dom/components/common#ref-callback) along with a state
+ * for storing the element once it has mounted, so that the side nav can bind event listeners to the element
+ * once it is mounted.
+ *
+ * Otherwise, the side nav can be mounted before the element (e.g. if the element is lazy loaded), which would prevent the
+ * event listeners from being set up.
+ *
+ * State is required as opposed to just a ref so that the effects in the side nav can react to the element actually being mounted,
+ * as ref values cannot be added as effect dependencies.
+ */
+export const TopNavStartProvider = ({
+  children
+}) => {
+  const [element, setElement] = useState(null);
+  return /*#__PURE__*/React.createElement(TopNavStartElement.Provider, {
+    value: element
+  }, /*#__PURE__*/React.createElement(TopNavStartAttachRef.Provider, {
+    value: setElement
+  }, children));
+};

package/dist/es2019/context/top-nav-start/top-nav-start-context.js

@@ -0,0 +1,20 @@
+import { createContext } from 'react';
+import __noop from '@atlaskit/ds-lib/noop';
+
+/**
+ * Context for the TopNavStart container element
+ * Used to power the side nav flyout by allowing the side nav to bind event listeners to the element, so we can
+ * keep the flyout open while the user mouses from the top bar to the side nav.
+ */
+export const TopNavStartElement = /*#__PURE__*/createContext(null);
+
+/**
+ * Context for the callback ref used to respond to the TopNavStart element ref being attached. It is used to update the
+ * `TopNavStartElement` state so consumers can react to the ref being attached.
+ *
+ * e.g. Once the TopNavStart element has been mounted, the side nav can bind mouse event listeners to it.
+ *
+ * A callback ref is needed because the side nav can be mounted before elements in the top bar (e.g. if the element is lazy loaded),
+ * which happens in Jira and Confluence), which would prevent the event listeners from being set up.
+ */
+export const TopNavStartAttachRef = /*#__PURE__*/createContext(__noop);

package/dist/es2019/entry-points/experimental/color-utils/parse-hex.js

@@ -0,0 +1 @@
+export { parseHex } from '../../../ui/top-nav-items/themed/color-utils/formats/hex';

package/dist/es2019/entry-points/experimental/color-utils/parse-hsl.js

@@ -0,0 +1 @@
+export { parseHsl } from '../../../ui/top-nav-items/themed/color-utils/formats/hsl';

package/dist/es2019/entry-points/experimental/color-utils/parse-rgb.js

@@ -0,0 +1 @@
+export { parseRgb } from '../../../ui/top-nav-items/themed/color-utils/formats/rgb';

package/dist/es2019/entry-points/experimental/color-utils/parse-user-color.js

@@ -0,0 +1 @@
+export { parseUserColor } from '../../../ui/top-nav-items/themed/color-utils/parse-user-color';

package/dist/es2019/entry-points/experimental/top-nav-button.js

@@ -0,0 +1 @@
+export { Button as TopNavButton, LinkButton as TopNavLinkButton, IconButton as TopNavIconButton, LinkIconButton as TopNavLinkIconButton } from '../../ui/top-nav-items/themed/migration';

package/dist/es2019/entry-points/experimental/use-has-custom-theme.js

@@ -0,0 +1 @@
+export { useHasCustomTheme } from '../../ui/top-nav-items/themed/has-custom-theme-context';

package/dist/es2019/entry-points/experimental/use-legacy-search-theme.js

@@ -0,0 +1 @@
+export { useLegacySearchTheme } from '../../ui/top-nav-items/themed/search';

package/dist/es2019/entry-points/layout/aside.js

@@ -0,0 +1 @@
+export { Aside } from '../../ui/page-layout/aside';