nuance-ui 0.1.7 → 0.1.9

package/dist/runtime/components/tree/_ui/tree-item.vue

@@ -0,0 +1,172 @@
+<script setup>
+import { useTheme } from "@nui/composals";
+import { getThemeColor, isFalsy } from "@nui/utils";
+import { computed } from "vue";
+import Button from "../../button/button.vue";
+import { useRovingFocus } from "../../roving-focus";
+import RovingFocusItem from "../../roving-focus/roving-focus-item.vue";
+import { useTreeState } from "../lib/context";
+const { item, level } = defineProps({
+  item: { type: Object, required: true },
+  level: { type: Number, required: true }
+});
+const {
+  icon = "gravity-ui:folder",
+  trailingIcon = "gravity-ui:folder-open",
+  value,
+  label,
+  children,
+  disabled
+} = item;
+const { value: theme } = useTheme();
+const isFolder = computed(() => !isFalsy(children));
+const ctx = useTreeState();
+const selected = computed(() => ctx.selected.value.includes(value));
+const expanded = computed(() => ctx.expanded.value.includes(value));
+const active = computed(() => ctx.active.value === value);
+const { icon: fileIcon, color } = ctx.iconResolver(item);
+const { focus } = useRovingFocus();
+function handleClick(event) {
+  if (event.shiftKey)
+    ctx.toggle("select", value, "range");
+  else if (event.ctrlKey || event.metaKey)
+    ctx.toggle("select", value, "multiple");
+  else
+    ctx.toggle("select", value, "single");
+  if (isFolder.value && !event.ctrlKey && !event.metaKey && !event.shiftKey)
+    ctx.toggle("expand", value);
+}
+function handleKeyDown(event) {
+  switch (event.key) {
+    // Arrow Left - закрыть папку или перейти к родителю
+    case "ArrowLeft": {
+      event.preventDefault();
+      if (isFolder.value && expanded.value)
+        return ctx.off("expand", value);
+      else
+        return focus("prev", event.currentTarget);
+    }
+    // Arrow Right - открыть папку или перейти к первому ребенку
+    case "ArrowRight": {
+      event.preventDefault();
+      if (isFolder.value && !expanded.value)
+        return ctx.on("expand", value);
+      else if (expanded.value)
+        return focus("next", event.currentTarget);
+      break;
+    }
+    // Enter/Space - выбор элемента
+    case "Enter": {
+      ctx.on("select", value);
+      return ctx.setActive(value);
+    }
+    case " ": {
+      event.preventDefault();
+      if (event.shiftKey)
+        return ctx.toggle("select", value, "range");
+      else if (event.ctrlKey || event.metaKey)
+        return ctx.toggle("select", value, "multiple");
+      return ctx.toggle("select", value, "single");
+    }
+  }
+}
+</script>
+
+<template>
+	<li :class='$style.root' role='presentation'>
+		<RovingFocusItem>
+			<Button
+				:size='ctx.size'
+				:color='ctx.color'
+				:variant='ctx.variant'
+				:disabled
+				role='treeitem'
+				:classes='{
+  root: $style.button,
+  label: $style.label,
+  inner: $style.inner,
+  section: $style.section
+}'
+				:aria-level='level'
+				:aria-selected='selected'
+				:mod='{ active, selected, level }'
+				@click.prevent='handleClick'
+				@keydown.prevent='handleKeyDown'
+			>
+				<template v-if='isFolder' #leftSection>
+					<Icon v-if='expanded' :class='$style.icon' :name='trailingIcon' />
+					<Icon v-else :class='$style.icon' :name='icon' />
+				</template>
+				<template v-else #leftSection>
+					<Icon
+						:class='$style.icon'
+						:name='fileIcon'
+						:style='{ color: color && getThemeColor(color, theme) }'
+					/>
+				</template>
+				{{ label ?? value }}
+			</Button>
+		</RovingFocusItem>
+
+		<ul
+			v-if='expanded && item.children && item.children.length > 0'
+			:class='$style.list'
+			role='group'
+		>
+			<TreeItem
+				v-for='child in item.children'
+				:key='child.value'
+				:item='child'
+				:level='level + 1'
+			/>
+		</ul>
+	</li>
+</template>
+
+<style module lang="postcss">
+.root {
+	display: grid;
+	gap: .25rem;
+}
+
+.button {
+	.inner {
+		display: grid;
+		grid-template-columns: auto 1fr auto;
+
+		color: var(--color-text);
+
+		.label {
+			font-weight: 500;
+		}
+	}
+
+	&[data-active],
+	&[data-selected] {
+		.inner {
+			color: var(--button-color);
+		}
+	}
+
+	&[data-selected] {
+		background: alpha(var(--button-color), .1);
+	}
+}
+
+.icon {
+	width: var(--tree-icon-size);
+	height: var(--tree-icon-size);
+}
+
+.list {
+	display: grid;
+	gap: .25rem;
+
+	margin-inline-start: 1rem;
+
+	padding-inline-start: .75rem;
+	border-left: 1px solid var(--color-gray-4);
+
+	list-style: none;
+}
+</style>

package/dist/runtime/components/tree/_ui/tree-root.d.vue.ts

@@ -0,0 +1,39 @@
+import type { ButtonProps } from '@nui/components';
+import type { RovingFocusProps } from '../../roving-focus/roving-focus.vue.js';
+import type { TreeIconResolver, TreeModels } from '../model.js';
+export type TreeRootProps<T extends string = string> = RovingFocusProps & {
+    iconResolver?: TreeIconResolver<T>;
+    removable?: boolean;
+    selectable?: boolean;
+    variant?: ButtonProps['variant'];
+    color?: ButtonProps['color'];
+    size?: ButtonProps['size'];
+};
+declare const __VLS_export: <T extends string = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<(RovingFocusProps & {
+        iconResolver?: TreeIconResolver<T> | undefined;
+        removable?: boolean;
+        selectable?: boolean;
+        variant?: ButtonProps["variant"];
+        color?: ButtonProps["color"];
+        size?: ButtonProps["size"];
+    } & {
+        tree: TreeModels<T>["tree"];
+        active?: TreeModels<T>["active"];
+        selected?: TreeModels<T>["selected"];
+        expanded?: TreeModels<T>["expanded"];
+    }) & __VLS_EmitsToProps<__VLS_NormalizeEmits<((evt: "update:tree", value: import("@nui/components").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void)>>> & import("vue").PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "update:tree", value: import("@nui/components").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/tree/_ui/tree-root.vue

@@ -0,0 +1,87 @@
+<script setup>
+import { useStyleResolver } from "@nui/composals";
+import { getSize, removeTreeNodes } from "@nui/utils";
+import { onClickOutside, useEventListener } from "@vueuse/core";
+import { useTemplateRef } from "vue";
+import Box from "../../box.vue";
+import RovingFocus from "../../roving-focus/roving-focus.vue";
+import { useProvideTreeState } from "../lib/context";
+const {
+  color,
+  attr,
+  loop,
+  orientation,
+  variant = "subtle",
+  size = "compact-sm",
+  iconResolver = () => ({ icon: "gravity-ui:file" }),
+  removable = false,
+  selectable = false
+} = defineProps({
+  loop: { type: Boolean, required: false },
+  orientation: { type: String, required: false },
+  attr: { type: String, required: false },
+  iconResolver: { type: Function, required: false },
+  removable: { type: Boolean, required: false },
+  selectable: { type: Boolean, required: false },
+  variant: { type: String, required: false },
+  color: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const tree = defineModel("tree", { type: Array, ...{ required: true } });
+const active = defineModel("active", { type: null, ...{ default: null } });
+const selected = defineModel("selected", { type: Array, ...{ default: [] } });
+const expanded = defineModel("expanded", { type: Array, ...{ default: [] } });
+const style = useStyleResolver(() => ({
+  "--icon-size": getSize(size)
+}));
+const root = useTemplateRef("parent");
+onClickOutside(root, () => selected.value = []);
+useProvideTreeState({
+  tree,
+  active,
+  selected,
+  expanded,
+  iconResolver,
+  size,
+  color,
+  variant,
+  selectable
+});
+if (removable) {
+  useEventListener(root, "keydown", (event) => {
+    if (event.key === "Delete") {
+      event.preventDefault();
+      return tree.value = removeTreeNodes(tree.value, selected.value);
+    }
+  });
+}
+</script>
+
+<template>
+	<RovingFocus :attr :loop :orientation>
+		<Box
+			is='ul'
+			ref='parent'
+			role='tree'
+			:style
+			:class='$style.root'
+			@keydown.esc.prevent='selected.value = []'
+		>
+			<slot />
+		</Box>
+	</RovingFocus>
+</template>
+
+<style module lang="postcss">
+.root {
+	--tree-icon-size: var(--spacing-md);
+
+	display: flex;
+	flex-direction: column;
+	gap: .25rem;
+
+	padding-inline-start: 0;
+
+	list-style: none;
+}
+</style>

package/dist/runtime/components/tree/_ui/tree-root.vue.d.ts

@@ -0,0 +1,39 @@
+import type { ButtonProps } from '@nui/components';
+import type { RovingFocusProps } from '../../roving-focus/roving-focus.vue.js';
+import type { TreeIconResolver, TreeModels } from '../model.js';
+export type TreeRootProps<T extends string = string> = RovingFocusProps & {
+    iconResolver?: TreeIconResolver<T>;
+    removable?: boolean;
+    selectable?: boolean;
+    variant?: ButtonProps['variant'];
+    color?: ButtonProps['color'];
+    size?: ButtonProps['size'];
+};
+declare const __VLS_export: <T extends string = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<(RovingFocusProps & {
+        iconResolver?: TreeIconResolver<T> | undefined;
+        removable?: boolean;
+        selectable?: boolean;
+        variant?: ButtonProps["variant"];
+        color?: ButtonProps["color"];
+        size?: ButtonProps["size"];
+    } & {
+        tree: TreeModels<T>["tree"];
+        active?: TreeModels<T>["active"];
+        selected?: TreeModels<T>["selected"];
+        expanded?: TreeModels<T>["expanded"];
+    }) & __VLS_EmitsToProps<__VLS_NormalizeEmits<((evt: "update:tree", value: import("@nui/components").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void)>>> & import("vue").PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "update:tree", value: import("@nui/components").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/tree/index.d.ts

@@ -0,0 +1 @@
+export * from './model.js';

package/dist/runtime/components/tree/index.js

@@ -0,0 +1 @@
+export * from "./model.js";

package/dist/runtime/components/tree/lib/context.d.ts

@@ -0,0 +1,32 @@
+import type { ButtonProps, TreeIconResolver, TreeItem } from '@nui/components';
+import type { ModelRef } from 'vue';
+type EventType = 'select' | 'expand';
+type SelectMode = 'single' | 'multiple' | 'range';
+export interface TreeContext<T extends string = string> {
+    tree: ModelRef<TreeItem<T>[]>;
+    active: ModelRef<T | null>;
+    selected: ModelRef<T[]>;
+    expanded: ModelRef<T[]>;
+    iconResolver: TreeIconResolver<T>;
+    selectable: boolean;
+    variant: ButtonProps['variant'];
+    color: ButtonProps['color'];
+    size: ButtonProps['size'];
+}
+export interface TreeState<T extends string = string> {
+    active: ModelRef<T | null>;
+    selected: ModelRef<T[]>;
+    expanded: ModelRef<T[]>;
+    iconResolver: TreeIconResolver<T>;
+    toggle: (type: EventType, value: T, mode?: SelectMode) => void;
+    on: ((type: 'expand', value: T) => void) & ((type: 'select', value: T, mode?: SelectMode) => void);
+    off: (type: EventType, value: T) => void;
+    setActive: (value: T | null) => void;
+    selectable: boolean;
+    variant: ButtonProps['variant'];
+    color: ButtonProps['color'];
+    size: ButtonProps['size'];
+}
+export declare function useProvideTreeState<T extends string = string>(ctx: TreeContext<T>): TreeState<T>;
+export declare function useTreeState<T extends string = string>(): TreeState<T>;
+export {};

package/dist/runtime/components/tree/lib/context.js

@@ -0,0 +1,103 @@
+import { createStrictInjection } from "@nui/helpers";
+import { getBranchChildren, getTreeItemsBetween } from "@nui/utils";
+const injectionKey = Symbol("nui-tree");
+const [useProvide, useState] = createStrictInjection(({
+  tree,
+  active,
+  selected,
+  expanded,
+  iconResolver,
+  selectable,
+  ...rest
+}) => {
+  const setActive = (value) => active.value = value;
+  function on(type, value, mode) {
+    if (type === "select") {
+      setActive(value);
+      if (!selectable)
+        return;
+      switch (mode) {
+        case "single":
+          return selected.value = [value];
+        case "multiple": {
+          const exist = selected.value.includes(value);
+          if (!exist)
+            selected.value = [...selected.value, value];
+          return;
+        }
+        case "range": {
+          if (!active.value || active.value === value)
+            return;
+          const range = getTreeItemsBetween(tree.value, active.value, value);
+          return selected.value = [.../* @__PURE__ */ new Set([...selected.value, ...range])];
+        }
+        default:
+          return selected.value = [value];
+      }
+    }
+    if (type === "expand") {
+      const exist = expanded.value.includes(value);
+      if (!exist)
+        expanded.value = [...expanded.value, value];
+      return;
+    }
+    return console.warn(`Unknown target type in NuiTree: ${type}`);
+  }
+  const off = (type, value) => {
+    switch (type) {
+      case "select": {
+        selected.value = selected.value.filter((i) => i !== value);
+        if (active.value === value)
+          active.value = selected.value[0] ?? null;
+        return;
+      }
+      case "expand": {
+        const children = new Set(getBranchChildren(tree.value, value));
+        return expanded.value = expanded.value.filter((v) => v !== value && !children.has(v));
+      }
+      default:
+        return console.warn(`Unknown target type in NuiTree: ${type}`);
+    }
+  };
+  const toggle = (type, value, mode = "single") => {
+    switch (type) {
+      case "select": {
+        const isSelected = selected.value.includes(value);
+        if (mode === "single")
+          return on(type, value, mode);
+        if (mode === "multiple")
+          return isSelected ? off(type, value) : on(type, value, mode);
+        if (mode === "range")
+          return on(type, value, mode);
+        return;
+      }
+      case "expand": {
+        const isExpanded = expanded.value.includes(value);
+        return isExpanded ? off(type, value) : on(type, value);
+      }
+      default:
+        console.warn(`Unknown target type in NuiTree: ${type}`);
+    }
+  };
+  return {
+    on,
+    off,
+    toggle,
+    setActive,
+    active,
+    selected,
+    expanded,
+    iconResolver,
+    selectable,
+    ...rest
+  };
+}, {
+  injectionKey,
+  name: "TreeState"
+});
+export function useProvideTreeState(ctx) {
+  return useProvide(ctx);
+}
+export function useTreeState() {
+  return useState();
+}

package/dist/runtime/components/tree/lib/get-default.d.ts

@@ -0,0 +1,7 @@
+import type { TreeItem } from '../model.js';
+/**
+ * Получает все элементы дерева с expanded: true
+ * @param items - массив элементов дерева
+ * @returns массив value элементов с expanded: true
+ */
+export declare function getExpandedItems<T extends string = string>(items: TreeItem<T>[]): T[];

package/dist/runtime/components/tree/lib/get-default.js

@@ -0,0 +1,10 @@
+export function getExpandedItems(items) {
+  const result = [];
+  for (const item of items) {
+    if (item.expanded === true)
+      result.push(item.value);
+    if (item.children && item.children.length > 0)
+      result.push(...getExpandedItems(item.children));
+  }
+  return result;
+}

package/dist/runtime/components/tree/model.d.ts

@@ -0,0 +1,33 @@
+import type { NuanceColor } from '@nui/types';
+export interface TreeModels<T extends string = string> {
+    active: T | null;
+    tree: TreeItem<T>[];
+    selected: T[];
+    expanded: T[];
+}
+export interface TreeItem<T extends string = string> {
+    /** @IconifyIcon */
+    icon?: string;
+    /** Value given to this item */
+    value: T;
+    /** Item label */
+    label?: string;
+    /** @IconifyIcon */
+    trailingIcon?: string;
+    /** Item default expanded */
+    expanded?: boolean;
+    /** Item disabled state */
+    disabled?: boolean;
+    /** Slot name */
+    slot?: string;
+    /** Item children */
+    children?: TreeItem<T>[];
+    /** Fires when item is selected */
+    onSelect?: (item: TreeItem<T>) => void;
+    /** Fires when item is toggled */
+    onToggle?: (item: TreeItem<T>) => void;
+}
+export type TreeIconResolver<T extends string = string> = (item: TreeItem<T>) => {
+    icon: string;
+    color?: NuanceColor;
+};

package/dist/runtime/components/tree/tree.d.vue.ts

@@ -0,0 +1,23 @@
+import type { TreeRootProps } from './_ui/tree-root.vue.js';
+import type { TreeModels } from './model.js';
+export interface TreeProps<T extends string = string> extends TreeRootProps<T> {
+}
+declare const __VLS_export: <T extends string = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<(TreeProps<T> & {
+        tree: TreeModels<T>["tree"];
+        active?: TreeModels<T>["active"];
+        selected?: TreeModels<T>["selected"];
+        expanded?: TreeModels<T>["expanded"];
+    }) & __VLS_EmitsToProps<__VLS_NormalizeEmits<((evt: "update:tree", value: import("./model.js").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void)>>> & import("vue").PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "update:tree", value: import("./model.js").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/tree/tree.vue

@@ -0,0 +1,46 @@
+<script setup>
+import UTreeItem from "./_ui/tree-item.vue";
+import TreeRoot from "./_ui/tree-root.vue";
+import { getExpandedItems } from "./lib/get-default";
+const {
+  color,
+  variant = "subtle",
+  size = "compact-sm",
+  ...props
+} = defineProps({
+  loop: { type: Boolean, required: false },
+  orientation: { type: String, required: false },
+  attr: { type: String, required: false },
+  iconResolver: { type: Function, required: false },
+  removable: { type: Boolean, required: false },
+  selectable: { type: Boolean, required: false },
+  variant: { type: String, required: false },
+  color: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const tree = defineModel("tree", { type: Array, ...{ required: true } });
+const active = defineModel("active", { type: null, ...{ default: null } });
+const selected = defineModel("selected", { type: Array, ...{ default: [] } });
+const expanded = defineModel("expanded", { type: Array, ...{ default: [] } });
+expanded.value = getExpandedItems(tree.value);
+</script>
+
+<template>
+	<TreeRoot
+		v-bind='props'
+		v-model:tree='tree'
+		v-model:active='active'
+		v-model:selected='selected'
+		v-model:expanded='expanded'
+		:size
+		:color
+		:variant
+	>
+		<UTreeItem
+			v-for='item in tree'
+			:key='item.value'
+			:item
+			:level='1'
+		/>
+	</TreeRoot>
+</template>

package/dist/runtime/components/tree/tree.vue.d.ts

@@ -0,0 +1,23 @@
+import type { TreeRootProps } from './_ui/tree-root.vue.js';
+import type { TreeModels } from './model.js';
+export interface TreeProps<T extends string = string> extends TreeRootProps<T> {
+}
+declare const __VLS_export: <T extends string = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<(TreeProps<T> & {
+        tree: TreeModels<T>["tree"];
+        active?: TreeModels<T>["active"];
+        selected?: TreeModels<T>["selected"];
+        expanded?: TreeModels<T>["expanded"];
+    }) & __VLS_EmitsToProps<__VLS_NormalizeEmits<((evt: "update:tree", value: import("./model.js").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void)>>> & import("vue").PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "update:tree", value: import("./model.js").TreeItem<T>[]) => void) & ((evt: "update:active", value: T | null) => void) & ((evt: "update:selected", value: T[]) => void) & ((evt: "update:expanded", value: T[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/composals/index.d.ts

@@ -1,4 +1,3 @@
 export * from './use-active-link.js';
-export * from './use-mod.js';
 export * from './use-style-resolver.js';
 export * from './use-theme.js';

package/dist/runtime/composals/index.js

@@ -1,4 +1,3 @@
 export * from "./use-active-link.js";
-export * from "./use-mod.js";
 export * from "./use-style-resolver.js";
 export * from "./use-theme.js";