@daikin-oss/design-system-web-components 2.0.0 → 2.0.1-next.1

package/dist/es/icon-registry.js

@@ -1,170 +1,155 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var _instance, _icons, _dynamicRegistrations, _cache;
+//#region src/icon-registry.ts
+/**
+* Type guard to check if registration is dynamic
+*/
 function isDynamicRegistration(registration) {
-  return "match" in registration && "fetch" in registration;
+	return "match" in registration && "fetch" in registration;
 }
+/**
+* Type guard to check if registration is direct
+*/
 function isDirectRegistration(registration) {
-  return "name" in registration && "svg" in registration;
+	return "name" in registration && "svg" in registration;
 }
+/**
+* Normalize SVG data to IconData format
+*/
 function normalizeIconData(svg) {
-  if (typeof svg === "string") {
-    return { mode: "mask", svg };
-  }
-  return { mode: "mask", ...svg };
+	if (typeof svg === "string") return {
+		mode: "mask",
+		svg
+	};
+	return {
+		mode: "mask",
+		...svg
+	};
 }
-const _IconRegistry = class _IconRegistry {
-  constructor() {
-    /** Map of registered icons by name */
-    __privateAdd(this, _icons, /* @__PURE__ */ new Map());
-    /** Array of dynamic icon registrations */
-    __privateAdd(this, _dynamicRegistrations, []);
-    /** Cache for dynamically fetched icons */
-    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
-  }
-  /**
-   * Get the singleton instance of IconRegistry
-   */
-  static getGlobalInstance() {
-    const instance = __privateGet(_IconRegistry, _instance) ?? __privateSet(_IconRegistry, _instance, new _IconRegistry());
-    return instance;
-  }
-  /**
-   * Register an icon or dynamic icon fetcher
-   * @param registration Icon registration configuration
-   *
-   * @example
-   * // Direct registration
-   * registry.register({ name: "custom-icon", svg: "<svg>...</svg>" });
-   *
-   * // Dynamic registration
-   * registry.register({
-   *   match: /^custom-/,
-   *   fetch: async (name) => {
-   *     const response = await fetch(`/icons/${name}.svg`);
-   *     return response.text();
-   *   }
-   * });
-   */
-  register(registration) {
-    if (isDirectRegistration(registration)) {
-      const iconData = normalizeIconData(registration.svg);
-      __privateGet(this, _icons).set(registration.name, iconData);
-    } else if (isDynamicRegistration(registration)) {
-      __privateGet(this, _dynamicRegistrations).push(registration);
-    }
-  }
-  /**
-   * Get an icon by name
-   * @param name Icon name
-   * @returns Promise that resolves to IconData or null if not found
-   */
-  async getIcon(name) {
-    const registered = __privateGet(this, _icons).get(name);
-    if (registered) {
-      return registered;
-    }
-    for (const registration of __privateGet(this, _dynamicRegistrations)) {
-      if (registration.match.test(name)) {
-        return this.fetchDynamicIcon(registration, name);
-      }
-    }
-    return null;
-  }
-  /**
-   * Check if an icon is registered (either directly or through dynamic registration)
-   * @param name Icon name
-   * @returns true if icon is available
-   */
-  hasIcon(name) {
-    if (__privateGet(this, _icons).has(name)) {
-      return true;
-    }
-    return __privateGet(this, _dynamicRegistrations).some(
-      (registration) => registration.match.test(name)
-    );
-  }
-  /**
-   * Get all directly registered icon names
-   * @returns Array of icon names
-   */
-  getRegisteredIconNames() {
-    return Array.from(__privateGet(this, _icons).keys());
-  }
-  /**
-   * Get all dynamic registration patterns
-   * @returns Array of regex patterns
-   */
-  getDynamicPatterns() {
-    return __privateGet(this, _dynamicRegistrations).map((reg) => reg.match);
-  }
-  /**
-   * Clear all registrations and cache
-   */
-  clear() {
-    __privateGet(this, _icons).clear();
-    __privateGet(this, _dynamicRegistrations).length = 0;
-    __privateGet(this, _cache).clear();
-  }
-  /**
-   * Remove a specific icon registration
-   * @param name Icon name to remove
-   */
-  unregister(name) {
-    const existed = __privateGet(this, _icons).has(name);
-    __privateGet(this, _icons).delete(name);
-    return existed;
-  }
-  /**
-   * Fetch icon from dynamic registration
-   * @param registration Dynamic registration
-   * @param name Icon name
-   * @returns Promise that resolves to IconData or null
-   */
-  async fetchDynamicIcon(registration, name) {
-    const cacheKey = `${registration.match.source}\0${name}`;
-    const cached = __privateGet(this, _cache).get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-    const fetchPromise = this.performDynamicFetch(registration, name).then(
-      (result) => {
-        __privateGet(this, _cache).set(cacheKey, result);
-        return result;
-      }
-    );
-    __privateGet(this, _cache).set(cacheKey, fetchPromise);
-    return fetchPromise;
-  }
-  /**
-   * Perform the actual dynamic fetch
-   * @param registration Dynamic registration
-   * @param name Icon name
-   * @returns Promise that resolves to IconData or null
-   */
-  async performDynamicFetch(registration, name) {
-    try {
-      const result = await registration.fetch(name);
-      return normalizeIconData(result);
-    } catch (error) {
-      console.warn(`Failed to fetch dynamic icon "${name}":`, error);
-      return null;
-    }
-  }
-};
-_instance = new WeakMap();
-_icons = new WeakMap();
-_dynamicRegistrations = new WeakMap();
-_cache = new WeakMap();
-__privateAdd(_IconRegistry, _instance);
-let IconRegistry = _IconRegistry;
-const iconRegistry = IconRegistry.getGlobalInstance();
-export {
-  IconRegistry,
-  iconRegistry
+/**
+* Icon registry class that manages icon registration and retrieval
+*/
+var IconRegistry = class IconRegistry {
+	static #instance;
+	/** Map of registered icons by name */
+	#icons = /* @__PURE__ */ new Map();
+	/** Array of dynamic icon registrations */
+	#dynamicRegistrations = [];
+	/** Cache for dynamically fetched icons */
+	#cache = /* @__PURE__ */ new Map();
+	/**
+	* Get the singleton instance of IconRegistry
+	*/
+	static getGlobalInstance() {
+		return IconRegistry.#instance ??= new IconRegistry();
+	}
+	/**
+	* Register an icon or dynamic icon fetcher
+	* @param registration Icon registration configuration
+	*
+	* @example
+	* // Direct registration
+	* registry.register({ name: "custom-icon", svg: "<svg>...</svg>" });
+	*
+	* // Dynamic registration
+	* registry.register({
+	*   match: /^custom-/,
+	*   fetch: async (name) => {
+	*     const response = await fetch(`/icons/${name}.svg`);
+	*     return response.text();
+	*   }
+	* });
+	*/
+	register(registration) {
+		if (isDirectRegistration(registration)) {
+			const iconData = normalizeIconData(registration.svg);
+			this.#icons.set(registration.name, iconData);
+		} else if (isDynamicRegistration(registration)) this.#dynamicRegistrations.push(registration);
+	}
+	/**
+	* Get an icon by name
+	* @param name Icon name
+	* @returns Promise that resolves to IconData or null if not found
+	*/
+	async getIcon(name) {
+		const registered = this.#icons.get(name);
+		if (registered) return registered;
+		for (const registration of this.#dynamicRegistrations) if (registration.match.test(name)) return this.fetchDynamicIcon(registration, name);
+		return null;
+	}
+	/**
+	* Check if an icon is registered (either directly or through dynamic registration)
+	* @param name Icon name
+	* @returns true if icon is available
+	*/
+	hasIcon(name) {
+		if (this.#icons.has(name)) return true;
+		return this.#dynamicRegistrations.some((registration) => registration.match.test(name));
+	}
+	/**
+	* Get all directly registered icon names
+	* @returns Array of icon names
+	*/
+	getRegisteredIconNames() {
+		return Array.from(this.#icons.keys());
+	}
+	/**
+	* Get all dynamic registration patterns
+	* @returns Array of regex patterns
+	*/
+	getDynamicPatterns() {
+		return this.#dynamicRegistrations.map((reg) => reg.match);
+	}
+	/**
+	* Clear all registrations and cache
+	*/
+	clear() {
+		this.#icons.clear();
+		this.#dynamicRegistrations.length = 0;
+		this.#cache.clear();
+	}
+	/**
+	* Remove a specific icon registration
+	* @param name Icon name to remove
+	*/
+	unregister(name) {
+		const existed = this.#icons.has(name);
+		this.#icons.delete(name);
+		return existed;
+	}
+	/**
+	* Fetch icon from dynamic registration
+	* @param registration Dynamic registration
+	* @param name Icon name
+	* @returns Promise that resolves to IconData or null
+	*/
+	async fetchDynamicIcon(registration, name) {
+		const cacheKey = `${registration.match.source}\0${name}`;
+		const cached = this.#cache.get(cacheKey);
+		if (cached) return cached;
+		const fetchPromise = this.performDynamicFetch(registration, name).then((result) => {
+			this.#cache.set(cacheKey, result);
+			return result;
+		});
+		this.#cache.set(cacheKey, fetchPromise);
+		return fetchPromise;
+	}
+	/**
+	* Perform the actual dynamic fetch
+	* @param registration Dynamic registration
+	* @param name Icon name
+	* @returns Promise that resolves to IconData or null
+	*/
+	async performDynamicFetch(registration, name) {
+		try {
+			return normalizeIconData(await registration.fetch(name));
+		} catch (error) {
+			console.warn(`Failed to fetch dynamic icon "${name}":`, error);
+			return null;
+		}
+	}
 };
+/**
+* Global icon registry instance
+*/
+var iconRegistry = IconRegistry.getGlobalInstance();
+//#endregion
+export { IconRegistry, iconRegistry };

package/dist/es/index.js

@@ -1,43 +1,45 @@
-import { DaikinAccordion } from "./components/accordion/daikin-accordion.js";
 import { DaikinAccordionItem } from "./components/accordion-item/daikin-accordion-item.js";
+import { DaikinAccordion } from "./components/accordion/daikin-accordion.js";
 import { DaikinAvatar } from "./components/avatar/daikin-avatar.js";
 import { DaikinBadge } from "./components/badge/daikin-badge.js";
-import { DaikinBreadcrumb } from "./components/breadcrumb/daikin-breadcrumb.js";
+import { DaikinLink } from "./components/link/daikin-link.js";
 import { DaikinBreadcrumbItem } from "./components/breadcrumb-item/daikin-breadcrumb-item.js";
+import { DaikinBreadcrumb } from "./components/breadcrumb/daikin-breadcrumb.js";
 import { DaikinButton } from "./components/button/daikin-button.js";
+import { IconRegistry, iconRegistry } from "./icon-registry.js";
+import { DaikinIcon, iconList } from "./components/icon/daikin-icon.js";
+import { DaikinIconButton } from "./components/icon-button/daikin-icon-button.js";
 import { DaikinCalendar } from "./components/calendar/daikin-calendar.js";
-import { DaikinCard } from "./components/card/daikin-card.js";
 import { DaikinCardFooter } from "./components/card-footer/daikin-card-footer.js";
 import { DaikinCardHeader } from "./components/card-header/daikin-card-header.js";
-import { DaikinCarousel } from "./components/carousel/daikin-carousel.js";
+import { DaikinCard } from "./components/card/daikin-card.js";
 import { DaikinCarouselItem } from "./components/carousel-item/daikin-carousel-item.js";
-import { DaikinCheckbox } from "./components/checkbox/daikin-checkbox.js";
+import { DaikinCarousel } from "./components/carousel/daikin-carousel.js";
 import { DaikinCheckboxGroup } from "./components/checkbox-group/daikin-checkbox-group.js";
+import { DaikinCheckbox } from "./components/checkbox/daikin-checkbox.js";
 import { DaikinChip } from "./components/chip/daikin-chip.js";
 import { DaikinCombobox, defaultFilterFn } from "./components/combobox/daikin-combobox.js";
 import { DaikinDatePicker } from "./components/date-picker/daikin-date-picker.js";
 import { DaikinDivider } from "./components/divider/daikin-divider.js";
-import { DaikinDrawer } from "./components/drawer/daikin-drawer.js";
 import { DaikinDrawerFooter } from "./components/drawer-footer/daikin-drawer-footer.js";
 import { DaikinDrawerHeader } from "./components/drawer-header/daikin-drawer-header.js";
-import { DaikinDropdown } from "./components/dropdown/daikin-dropdown.js";
+import { DaikinDrawer } from "./components/drawer/daikin-drawer.js";
 import { DaikinDropdownItem } from "./components/dropdown-item/daikin-dropdown-item.js";
+import { DaikinDropdown } from "./components/dropdown/daikin-dropdown.js";
 import { DaikinEmptyState } from "./components/empty-state/daikin-empty-state.js";
-import { DaikinIcon, iconList } from "./components/icon/daikin-icon.js";
-import { DaikinIconButton } from "./components/icon-button/daikin-icon-button.js";
 import { DaikinInlineNotification } from "./components/inline-notification/daikin-inline-notification.js";
+import { DaikinStatusMessage } from "./components/status-message/daikin-status-message.js";
 import { DaikinInputGroup } from "./components/input-group/daikin-input-group.js";
-import { DaikinLink } from "./components/link/daikin-link.js";
-import { DaikinList } from "./components/list/daikin-list.js";
 import { DaikinListItem } from "./components/list-item/daikin-list-item.js";
+import { DaikinList } from "./components/list/daikin-list.js";
 import { DaikinLoading } from "./components/loading/daikin-loading.js";
 import { DaikinLogo } from "./components/logo/daikin-logo.js";
+import { DaikinNavigationItem } from "./components/navigation-item/daikin-navigation-item.js";
 import { DaikinMenu } from "./components/menu/daikin-menu.js";
 import { DaikinModal } from "./components/modal/daikin-modal.js";
 import { DaikinModalFooter } from "./components/modal-footer/daikin-modal-footer.js";
 import { DaikinModalHeader } from "./components/modal-header/daikin-modal-header.js";
 import { DaikinNavigation } from "./components/navigation/daikin-navigation.js";
-import { DaikinNavigationItem } from "./components/navigation-item/daikin-navigation-item.js";
 import { DaikinPagination } from "./components/pagination/daikin-pagination.js";
 import { DaikinProgressBar } from "./components/progress-bar/daikin-progress-bar.js";
 import { DaikinProgressIndicator } from "./components/progress-indicator/daikin-progress-indicator.js";
@@ -46,12 +48,11 @@ import { DaikinRadio } from "./components/radio/daikin-radio.js";
 import { DaikinRadioGroup } from "./components/radio-group/daikin-radio-group.js";
 import { DaikinSelect } from "./components/select/daikin-select.js";
 import { DaikinSlider } from "./components/slider/daikin-slider.js";
-import { DaikinStatusMessage } from "./components/status-message/daikin-status-message.js";
 import { DaikinTab } from "./components/tab/daikin-tab.js";
 import { DaikinTabPanels } from "./components/tab-panels/daikin-tab-panels.js";
-import { DaikinTable } from "./components/table/daikin-table.js";
 import { DaikinTableCell } from "./components/table-cell/daikin-table-cell.js";
 import { DaikinTableHeaderCell } from "./components/table-header-cell/daikin-table-header-cell.js";
+import { DaikinTable } from "./components/table/daikin-table.js";
 import { DaikinTabs } from "./components/tabs/daikin-tabs.js";
 import { DaikinTag } from "./components/tag/daikin-tag.js";
 import { DaikinTextArea } from "./components/text-area/daikin-text-area.js";
@@ -68,96 +69,6 @@ import { DaikinTreeSection } from "./components/tree-section/daikin-tree-section
 import { DaikinVerticalNavigation } from "./components/vertical-navigation/daikin-vertical-navigation.js";
 import { DaikinVerticalNavigationItem } from "./components/vertical-navigation-item/daikin-vertical-navigation-item.js";
 import { DaikinVerticalNavigationMenuItem } from "./components/vertical-navigation-menu-item/daikin-vertical-navigation-menu-item.js";
-import { IconRegistry, iconRegistry } from "./icon-registry.js";
+import "./components/index.js";
 import { getNavigationTarget, getSPANavigationURL, isInternalNavigation, shouldSPANavigate } from "./navigation.js";
-export {
-  DaikinAccordion,
-  DaikinAccordionItem,
-  DaikinAvatar,
-  DaikinBadge,
-  DaikinBreadcrumb,
-  DaikinBreadcrumbItem,
-  DaikinButton,
-  DaikinCalendar,
-  DaikinCard,
-  DaikinCardFooter,
-  DaikinCardHeader,
-  DaikinCarousel,
-  DaikinCarouselItem,
-  DaikinCheckbox,
-  DaikinCheckboxGroup,
-  DaikinChip,
-  DaikinCombobox,
-  DaikinDatePicker,
-  DaikinDivider,
-  DaikinDrawer,
-  DaikinDrawerFooter,
-  DaikinDrawerHeader,
-  DaikinDropdown,
-  DaikinDropdownItem,
-  DaikinEmptyState,
-  DaikinIcon,
-  DaikinIconButton,
-  DaikinInlineNotification,
-  DaikinInputGroup,
-  DaikinLink,
-  DaikinList,
-  DaikinListItem,
-  DaikinLoading,
-  DaikinLogo,
-  DaikinMenu,
-  DaikinModal,
-  DaikinModalFooter,
-  DaikinModalHeader,
-  DaikinNavigation,
-  DaikinNavigationItem,
-  DaikinPagination,
-  DaikinProgressBar,
-  DaikinProgressIndicator,
-  DaikinProgressIndicatorItem,
-  DaikinRadio,
-  DaikinRadioGroup,
-  DaikinSelect,
-  DaikinSlider,
-  DaikinStatusMessage,
-  DaikinTab,
-  DaikinTabPanels,
-  DaikinTable,
-  DaikinTableCell,
-  DaikinTableHeaderCell,
-  DaikinTabs,
-  DaikinTag,
-  DaikinTextArea,
-  DaikinTextField,
-  DaikinTextMaskedField,
-  DaikinTimePicker,
-  DaikinToastNotification,
-  DaikinToastNotificationManager,
-  DaikinToggle,
-  DaikinTooltip,
-  DaikinTree,
-  DaikinTreeItem,
-  DaikinTreeSection,
-  DaikinVerticalNavigation,
-  DaikinVerticalNavigationItem,
-  DaikinVerticalNavigationMenuItem,
-  IconRegistry,
-  calcDigitInput,
-  cvaTreeChildren,
-  defaultFilterFn,
-  formatPartsForUI,
-  formatTimeForUI,
-  getNavigationTarget,
-  getSPANavigationURL,
-  getTimeItemInSelection,
-  iconList,
-  iconRegistry,
-  isInternalNavigation,
-  isTimeOutOfRange,
-  isValidValueTime,
-  parsePartsFromUIValue,
-  shouldSPANavigate,
-  timeValueToUI,
-  tryParseTimeFromUIValue,
-  uiToTimeValue
-};
+export { DaikinAccordion, DaikinAccordionItem, DaikinAvatar, DaikinBadge, DaikinBreadcrumb, DaikinBreadcrumbItem, DaikinButton, DaikinCalendar, DaikinCard, DaikinCardFooter, DaikinCardHeader, DaikinCarousel, DaikinCarouselItem, DaikinCheckbox, DaikinCheckboxGroup, DaikinChip, DaikinCombobox, DaikinDatePicker, DaikinDivider, DaikinDrawer, DaikinDrawerFooter, DaikinDrawerHeader, DaikinDropdown, DaikinDropdownItem, DaikinEmptyState, DaikinIcon, DaikinIconButton, DaikinInlineNotification, DaikinInputGroup, DaikinLink, DaikinList, DaikinListItem, DaikinLoading, DaikinLogo, DaikinMenu, DaikinModal, DaikinModalFooter, DaikinModalHeader, DaikinNavigation, DaikinNavigationItem, DaikinPagination, DaikinProgressBar, DaikinProgressIndicator, DaikinProgressIndicatorItem, DaikinRadio, DaikinRadioGroup, DaikinSelect, DaikinSlider, DaikinStatusMessage, DaikinTab, DaikinTabPanels, DaikinTable, DaikinTableCell, DaikinTableHeaderCell, DaikinTabs, DaikinTag, DaikinTextArea, DaikinTextField, DaikinTextMaskedField, DaikinTimePicker, DaikinToastNotification, DaikinToastNotificationManager, DaikinToggle, DaikinTooltip, DaikinTree, DaikinTreeItem, DaikinTreeSection, DaikinVerticalNavigation, DaikinVerticalNavigationItem, DaikinVerticalNavigationMenuItem, IconRegistry, calcDigitInput, cvaTreeChildren, defaultFilterFn, formatPartsForUI, formatTimeForUI, getNavigationTarget, getSPANavigationURL, getTimeItemInSelection, iconList, iconRegistry, isInternalNavigation, isTimeOutOfRange, isValidValueTime, parsePartsFromUIValue, shouldSPANavigate, timeValueToUI, tryParseTimeFromUIValue, uiToTimeValue };

package/dist/es/is-client.js

@@ -1,5 +1,5 @@
 import { isServer } from "lit";
-const isClient = !isServer && typeof window !== "undefined";
-export {
-  isClient
-};
+//#region src/is-client.ts
+var isClient = !isServer && typeof window !== "undefined";
+//#endregion
+export { isClient };

package/dist/es/navigation.js

@@ -1,62 +1,78 @@
-import "./base/dds-element.js";
-import "./base/dds-form-element.js";
-import "lit/decorators.js";
-import "./base/define.js";
+import "./base/index.js";
+//#region src/navigation.ts
+/**
+* Type guard to check if an element implements `DDSNavigable`.
+*
+* @param element - The element to check.
+* @returns True if the element implements `DDSNavigable`, otherwise false.
+*/
 function isDDSNavigable(element) {
-  return typeof element === "object" && element != null && // We intentionally skip the `instanceof` check to avoid issues with multiple versions of the library.
-  "getDDSNavigationTarget" in element;
+	return typeof element === "object" && element != null && "getDDSNavigationTarget" in element;
 }
+/**
+* Extracts a navigation target from a component that implements `DDSNavigable`.
+*
+* @param element - Candidate element that may implement `DDSNavigable`.
+* @returns The navigation target when available, otherwise null.
+*/
 function getNavigationTarget(element) {
-  if (isDDSNavigable(element)) {
-    return element.getDDSNavigationTarget();
-  }
-  return null;
+	if (isDDSNavigable(element)) return element.getDDSNavigationTarget();
+	return null;
 }
+/**
+* Returns true when the href points to the current origin using http(s) or a relative URL.
+*
+* @param href - Destination URL or path to evaluate.
+* @param base - Base URL used when resolving relative paths.
+* @param origin - Origin to compare against after resolving the URL.
+* @returns True when the navigation stays within the same origin.
+*/
 function isInternalNavigation(href, base = document.baseURI, origin = location.origin) {
-  var _a;
-  try {
-    const scheme = (_a = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(href)) == null ? void 0 : _a[0];
-    if (scheme && !/^https?:$/.test(scheme)) {
-      return false;
-    }
-    const url = new URL(href, base);
-    return url.origin === origin;
-  } catch {
-    return false;
-  }
+	try {
+		const scheme = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(href)?.[0];
+		if (scheme && !/^https?:$/.test(scheme)) return false;
+		return new URL(href, base).origin === origin;
+	} catch {
+		return false;
+	}
 }
-function shouldSPANavigate(event, element = event == null ? void 0 : event.target, target = getNavigationTarget(element)) {
-  if (!element) {
-    return false;
-  }
-  if (event) {
-    if (event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) {
-      return false;
-    }
-    if (event.button !== 0) {
-      return false;
-    }
-  }
-  if (!target || (target.target || "_self") !== "_self" || !isInternalNavigation(target.href)) {
-    return false;
-  }
-  return true;
+/**
+* Determines whether a click should be handled by SPA navigation rules.
+*
+* @param event - Mouse event that triggered navigation, if any.
+* @param element - Target element to evaluate when no event is available.
+* @param target - Navigation target information to evaluate when no event is available.
+* @returns True when the click qualifies for SPA navigation.
+*/
+function shouldSPANavigate(event, element = event?.target, target = getNavigationTarget(element)) {
+	if (!element) return false;
+	if (event) {
+		if (event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) return false;
+		if (event.button !== 0) return false;
+	}
+	if (!target || (target.target || "_self") !== "_self" || !isInternalNavigation(target.href)) return false;
+	return true;
 }
+/**
+* Finds the nearest ancestor element in the event path that implements `DDSNavigable`.
+*
+* @param paths - Event path to search through.
+* @returns The nearest `DDSNavigable` element, or null if none found.
+*/
 function getNearestDDSNavigable(paths) {
-  return paths.find((path) => isDDSNavigable(path)) ?? null;
+	return paths.find((path) => isDDSNavigable(path)) ?? null;
 }
+/**
+* Returns the URL to navigate to when a click event qualifies for SPA navigation, otherwise null.
+*
+* @param event - Mouse event that triggered navigation.
+* @returns The URL to navigate to, or null when the click does not qualify for SPA navigation.
+*/
 function getSPANavigationURL(event) {
-  const paths = event.composedPath();
-  const element = getNearestDDSNavigable(paths);
-  const target = element == null ? void 0 : element.getDDSNavigationTarget();
-  if (!target || !shouldSPANavigate(event, element, target)) {
-    return null;
-  }
-  return target.href;
+	const element = getNearestDDSNavigable(event.composedPath());
+	const target = element?.getDDSNavigationTarget();
+	if (!target || !shouldSPANavigate(event, element, target)) return null;
+	return target.href;
 }
-export {
-  getNavigationTarget,
-  getSPANavigationURL,
-  isInternalNavigation,
-  shouldSPANavigate
-};
+//#endregion
+export { getNavigationTarget, getSPANavigationURL, isInternalNavigation, shouldSPANavigate };