@weni/unnnic-system 3.13.0 → 3.14.0-alpha-teleports.0

package/src/components/ui/drawer/DrawerFooter.vue

@@ -0,0 +1,38 @@
+<script lang="ts" setup>
+import { type HTMLAttributes } from 'vue';
+import { cn } from '@/lib/utils';
+
+defineOptions({
+  name: 'UnnnicDrawerFooter',
+});
+
+const props = defineProps<{
+  class?: HTMLAttributes['class'];
+}>();
+</script>
+
+<template>
+  <footer :class="cn('unnnic-drawer__footer', props.class)">
+    <slot />
+  </footer>
+</template>
+
+<style lang="scss" scoped>
+@use '@/assets/scss/unnnic' as *;
+
+.unnnic-drawer__footer {
+  border-top: 1px solid $unnnic-color-border-soft;
+
+  margin-top: auto;
+  padding: $unnnic-space-6;
+
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  gap: $unnnic-space-2;
+
+  > * {
+    width: 100%;
+  }
+}
+</style>

package/src/components/ui/drawer/DrawerHeader.vue

@@ -0,0 +1,57 @@
+<script lang="ts" setup>
+import { type HTMLAttributes } from 'vue';
+import { cn } from '@/lib/utils';
+import UnnnicButton from '@/components/Button/Button.vue';
+import DrawerClose from './DrawerClose.vue';
+
+defineOptions({
+  name: 'UnnnicDrawerHeader',
+});
+
+const props = defineProps<{
+  class?: HTMLAttributes['class'];
+}>();
+</script>
+
+<template>
+  <header :class="cn('unnnic-drawer__header', props.class)">
+    <slot />
+
+    <template v-if="$slots.close">
+      <slot
+        name="close"
+        class="unnnic-drawer__close-button"
+      />
+    </template>
+    <template v-else>
+      <DrawerClose>
+        <UnnnicButton
+          iconCenter="close"
+          size="small"
+          type="tertiary"
+          class="unnnic-drawer__close-button"
+        />
+      </DrawerClose>
+    </template>
+  </header>
+</template>
+
+<style lang="scss" scoped>
+@use '@/assets/scss/unnnic' as *;
+
+.unnnic-drawer__header {
+  display: grid;
+  align-items: center;
+  grid-template-columns: 1fr auto;
+  padding: $unnnic-space-6;
+
+  gap: $unnnic-space-1;
+
+  border-bottom: 1px solid $unnnic-color-border-soft;
+}
+
+.unnnic-drawer__close-button {
+  grid-column: 2 / 3;
+  grid-row: 1 / 2;
+}
+</style>

package/src/components/ui/drawer/DrawerOverlay.vue

@@ -0,0 +1,33 @@
+<script lang="ts" setup>
+import type { DialogOverlayProps } from 'reka-ui';
+import { type HTMLAttributes } from 'vue';
+import { reactiveOmit } from '@vueuse/core';
+import { DrawerOverlay } from 'vaul-vue';
+import { cn } from '@/lib/utils';
+
+defineOptions({
+  name: 'UnnnicDrawerOverlay',
+});
+
+const props = defineProps<
+  DialogOverlayProps & { class?: HTMLAttributes['class'] }
+>();
+
+const delegatedProps = reactiveOmit(props, 'class');
+</script>
+
+<template>
+  <DrawerOverlay
+    v-bind="delegatedProps"
+    :class="cn('unnnic-drawer__overlay', props.class)"
+  />
+</template>
+
+<style lang="scss" scoped>
+.unnnic-drawer__overlay {
+  position: fixed;
+  inset: 0;
+
+  background: rgba(53, 57, 69, 0.65);
+}
+</style>

package/src/components/ui/drawer/DrawerTitle.vue

@@ -0,0 +1,37 @@
+<script lang="ts" setup>
+import type { DrawerTitleProps } from 'vaul-vue';
+import { type HTMLAttributes } from 'vue';
+import { reactiveOmit } from '@vueuse/core';
+import { DrawerTitle } from 'vaul-vue';
+import { cn } from '@/lib/utils';
+
+defineOptions({
+  name: 'UnnnicDrawerTitle',
+});
+
+const props = defineProps<
+  DrawerTitleProps & { class?: HTMLAttributes['class'] }
+>();
+
+const delegatedProps = reactiveOmit(props, 'class');
+</script>
+
+<template>
+  <DrawerTitle
+    v-bind="delegatedProps"
+    :class="cn('unnnic-drawer__title', props.class)"
+  >
+    <slot />
+  </DrawerTitle>
+</template>
+
+<style lang="scss" scoped>
+@use '@/assets/scss/unnnic' as *;
+
+.unnnic-drawer__title {
+  margin: 0;
+
+  color: $unnnic-color-fg-emphasized;
+  font: $unnnic-font-display-2;
+}
+</style>

package/src/components/ui/drawer/DrawerTrigger.vue

@@ -0,0 +1,31 @@
+<script setup lang="ts">
+import type { DrawerTriggerProps } from 'vaul-vue';
+import { DrawerTrigger } from 'vaul-vue';
+
+defineOptions({
+  name: 'UnnnicDrawerTrigger',
+});
+
+const props = defineProps<DrawerTriggerProps>();
+</script>
+
+<template>
+  <DrawerTrigger
+    v-bind="props"
+    class="unnnic-drawer__trigger"
+  >
+    <slot />
+  </DrawerTrigger>
+</template>
+
+<style lang="scss" scoped>
+@use '@/assets/scss/unnnic' as *;
+
+.unnnic-drawer__trigger {
+  border: none;
+  background: none;
+  padding: 0;
+  margin: 0;
+  cursor: pointer;
+}
+</style>

package/src/components/ui/drawer/index.ts

@@ -0,0 +1,10 @@
+export { default as Drawer } from './Drawer.vue';
+export { default as DrawerContent } from './DrawerContent.vue';
+export { default as DrawerDescription } from './DrawerDescription.vue';
+export { default as DrawerFooter } from './DrawerFooter.vue';
+export { default as DrawerHeader } from './DrawerHeader.vue';
+export { default as DrawerOverlay } from './DrawerOverlay.vue';
+export { default as DrawerTitle } from './DrawerTitle.vue';
+export { default as DrawerTrigger } from './DrawerTrigger.vue';
+export { default as DrawerClose } from './DrawerClose.vue';
+export { DrawerPortal } from 'vaul-vue';

package/src/components/ui/popover/PopoverContent.vue

@@ -1,8 +1,8 @@
 <template>
-  <PopoverPortal>
+  <PopoverPortal :to="portalTarget">
     <PopoverContent
       v-bind="{ ...forwarded, ...$attrs }"
-      :style="{ width: contentWidth }"
+      :style="{ width: contentWidth, zIndex: popoverZIndex }"
       :class="
         cn(
           'unnnic-popover',
@@ -34,6 +34,8 @@ import { computed, useSlots } from 'vue';
 import { reactiveOmit } from '@vueuse/core';
 import { PopoverContent, PopoverPortal, useForwardPropsEmits } from 'reka-ui';
 import { cn } from '@/lib/utils';
+import { useLayerZIndex } from '@/lib/layer-manager';
+import { useTeleportTarget } from '@/lib/teleport-target';
 
 defineOptions({
   inheritAttrs: false,
@@ -63,6 +65,9 @@ const forwarded = useForwardPropsEmits(delegatedProps, emits);
 
 const slots = useSlots() as Slots;
 
+const popoverZIndex = useLayerZIndex();
+const portalTarget = useTeleportTarget();
+
 const getComponentName = (vnode: VNode): string | undefined => {
   const componentType = vnode.type as { name?: string; __name?: string };
   return componentType?.name || componentType?.__name;
@@ -101,8 +106,6 @@ const contentWidth = computed(() => {
 $popover-space: $unnnic-space-4;
 
 .unnnic-popover {
-  z-index: 10000;
-
   border-radius: $unnnic-radius-2;
   box-shadow: $unnnic-shadow-1;
   border: 1px solid $unnnic-color-border-soft;

package/src/components/ui/popover/PopoverTrigger.vue

@@ -14,10 +14,14 @@ const props = defineProps<PopoverTriggerProps>();
   </PopoverTrigger>
 </template>
 
-<style scoped>
+<style lang="scss" scoped>
 .unnnic-popover-trigger {
   border: none;
   background: transparent;
   padding: 0;
+
+  & > * {
+    width: 100%;
+  }
 }
 </style>

package/src/components/ui/tooltip/Tooltip.vue

@@ -0,0 +1,21 @@
+<script setup lang="ts">
+import type { TooltipRootEmits, TooltipRootProps } from 'reka-ui';
+import { TooltipRoot, useForwardPropsEmits } from 'reka-ui';
+import { TooltipProvider } from 'reka-ui';
+
+const props = defineProps<TooltipRootProps>();
+const emits = defineEmits<TooltipRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <TooltipProvider
+    :delayDuration="100"
+    disableClosingTrigger
+  >
+    <TooltipRoot v-bind="forwarded">
+      <slot />
+    </TooltipRoot>
+  </TooltipProvider>
+</template>

package/src/components/ui/tooltip/TooltipContent.vue

@@ -0,0 +1,77 @@
+<script setup lang="ts">
+import type { TooltipContentEmits, TooltipContentProps } from 'reka-ui';
+import type { HTMLAttributes } from 'vue';
+import { reactiveOmit } from '@vueuse/core';
+import {
+  TooltipArrow,
+  TooltipContent,
+  TooltipPortal,
+  useForwardPropsEmits,
+} from 'reka-ui';
+import { cn } from '@/lib/utils';
+import { useLayerZIndex } from '@/lib/layer-manager';
+import { useTeleportTarget } from '@/lib/teleport-target';
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(
+  defineProps<TooltipContentProps & { class?: HTMLAttributes['class'] }>(),
+  {
+    sideOffset: 0,
+    class: undefined,
+  },
+);
+
+const emits = defineEmits<TooltipContentEmits>();
+
+const delegatedProps = reactiveOmit(props, 'class');
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+const tooltipZIndex = useLayerZIndex();
+const portalTarget = useTeleportTarget();
+</script>
+
+<template>
+  <TooltipPortal :to="portalTarget">
+    <TooltipContent
+      v-bind="{ ...forwarded, ...$attrs }"
+      :class="
+        cn(
+          'tooltip__content',
+          'animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
+          props.class,
+        )
+      "
+      :style="{ zIndex: tooltipZIndex }"
+    >
+      <slot />
+
+      <TooltipArrow class="tooltip__arrow" />
+    </TooltipContent>
+  </TooltipPortal>
+</template>
+
+<style lang="scss">
+@use '@/assets/scss/unnnic' as *;
+
+.tooltip__content {
+  background-color: $unnnic-color-gray-900;
+  color: $unnnic-color-white;
+  border-radius: $unnnic-radius-1;
+  padding: $unnnic-space-2;
+  box-shadow: $unnnic-shadow-1;
+  font: $unnnic-font-caption-2;
+
+  overflow-wrap: break-word;
+}
+
+.tooltip__arrow {
+  width: 10px;
+  height: 10px;
+  background-color: $unnnic-color-gray-900;
+  fill: $unnnic-color-gray-900;
+  transform: rotate(45deg) translate(-50%, -50%);
+}
+</style>

package/src/components/ui/tooltip/TooltipTrigger.vue

@@ -0,0 +1,24 @@
+<script setup lang="ts">
+import type { TooltipTriggerProps } from 'reka-ui';
+import { TooltipTrigger } from 'reka-ui';
+
+const props = defineProps<TooltipTriggerProps>();
+</script>
+
+<template>
+  <TooltipTrigger
+    v-bind="props"
+    as="div"
+    class="unnnic-tooltip-trigger"
+  >
+    <slot />
+  </TooltipTrigger>
+</template>
+
+<style lang="scss" scoped>
+.unnnic-tooltip-trigger {
+  position: relative;
+  display: inline-block;
+  overflow-wrap: break-word;
+}
+</style>

package/src/components/ui/tooltip/index.ts

@@ -0,0 +1,3 @@
+export { default as Tooltip } from './Tooltip.vue';
+export { default as TooltipContent } from './TooltipContent.vue';
+export { default as TooltipTrigger } from './TooltipTrigger.vue';

package/src/index.ts

@@ -1,14 +1,21 @@
 import type { App } from 'vue';
 import { components } from '@/components';
 import './assets/scss/tailwind.scss';
+import { setTeleportTarget, type TeleportTarget } from '@/lib/teleport-target';
 
 interface UnnnicPlugin {
-  install(app: App): void;
+  install(app: App, options?: UnnnicPluginOptions): void;
   [key: string]: any;
 }
 
+export interface UnnnicPluginOptions {
+  teleportTarget?: TeleportTarget | null;
+}
+
 const Unnnic: UnnnicPlugin = {
-  install(app: App) {
+  install(app: App, options?: UnnnicPluginOptions) {
+    setTeleportTarget(options?.teleportTarget ?? null);
+
     Object.keys(components).forEach((name) => {
       app.component(name, components[name] as any);
     });

package/src/lib/__tests__/teleport-target.spec.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ref } from 'vue';
+import {
+  getTeleportContainer,
+  getTeleportTarget,
+  setTeleportTarget,
+  useTeleportTarget,
+} from '@/lib/teleport-target';
+
+describe('teleport-target helpers', () => {
+  beforeEach(() => {
+    setTeleportTarget(null);
+    document.body.innerHTML = '';
+  });
+
+  it('stores and returns the raw teleport target', () => {
+    expect(getTeleportTarget()).toBeUndefined();
+
+    setTeleportTarget('#micro');
+    expect(getTeleportTarget()).toBe('#micro');
+
+    const element = document.createElement('section');
+    setTeleportTarget(element);
+    expect(getTeleportTarget()).toBe(element);
+  });
+
+  it('keeps the composable value in sync with global updates', () => {
+    const targetRef = useTeleportTarget();
+    expect(targetRef.value).toBeUndefined();
+
+    setTeleportTarget('#first');
+    expect(targetRef.value).toBe('#first');
+
+    setTeleportTarget('#second');
+    expect(targetRef.value).toBe('#second');
+  });
+
+  it('prefers local overrides over the shared teleport target', () => {
+    setTeleportTarget('#global');
+
+    const override = ref('#local-1');
+    const targetRef = useTeleportTarget(override);
+    expect(targetRef.value).toBe('#local-1');
+
+    override.value = '#local-2';
+    expect(targetRef.value).toBe('#local-2');
+  });
+
+  it('resolves DOM elements for selector targets', () => {
+    const host = document.createElement('div');
+    host.id = 'micro-root';
+    document.body.appendChild(host);
+
+    setTeleportTarget('#micro-root');
+    expect(getTeleportContainer()).toBe(host);
+  });
+
+  it('falls back to document.body when selector is missing or unset', () => {
+    setTeleportTarget('#missing');
+    expect(getTeleportContainer()).toBe(document.body);
+
+    setTeleportTarget(null);
+    expect(getTeleportContainer()).toBe(document.body);
+  });
+
+  it('returns the element itself when the target is an HTMLElement', () => {
+    const host = document.createElement('section');
+    document.body.appendChild(host);
+
+    setTeleportTarget(host);
+    expect(getTeleportContainer()).toBe(host);
+  });
+});

package/src/lib/layer-manager.ts

@@ -0,0 +1,64 @@
+import { onBeforeUnmount, onMounted, ref, type Ref } from 'vue';
+
+const BASE_LAYER_Z_INDEX = 1000;
+const DEFAULT_STEP = 5;
+
+const layerStack: number[] = [];
+const layerHandles = new Map<symbol, number>();
+
+interface LayerHandle {
+  id: symbol;
+  value: number;
+}
+
+function pushLayer(): LayerHandle {
+  const id = Symbol('layer');
+  const lastValue = layerStack.length
+    ? layerStack[layerStack.length - 1]
+    : BASE_LAYER_Z_INDEX;
+  const value = lastValue + DEFAULT_STEP;
+  layerStack.push(value);
+  layerHandles.set(id, value);
+  return { id, value };
+}
+
+function popLayer(id: symbol) {
+  const value = layerHandles.get(id);
+  if (value === undefined) {
+    return;
+  }
+
+  layerHandles.delete(id);
+  const index = layerStack.indexOf(value);
+  if (index !== -1) {
+    layerStack.splice(index, 1);
+  }
+}
+
+export interface LayerZIndexOptions {
+  offset?: number;
+}
+
+export function useLayerZIndex(options?: LayerZIndexOptions): Ref<number> {
+  const offset = options?.offset ?? 0;
+  const zIndex = ref(BASE_LAYER_Z_INDEX + offset);
+
+  let allocationId: symbol | null = null;
+
+  const allocate = () => {
+    const handle = pushLayer();
+    allocationId = handle.id;
+    zIndex.value = handle.value + offset;
+  };
+
+  onMounted(allocate);
+
+  onBeforeUnmount(() => {
+    if (allocationId) {
+      popLayer(allocationId);
+      allocationId = null;
+    }
+  });
+
+  return zIndex;
+}

package/src/lib/teleport-target.ts

@@ -0,0 +1,46 @@
+import { computed, shallowRef, toValue, type MaybeRefOrGetter } from 'vue';
+
+export type TeleportTarget = string | HTMLElement;
+
+const teleportTargetRef = shallowRef<TeleportTarget | null>(null);
+
+export function setTeleportTarget(target?: TeleportTarget | null) {
+  teleportTargetRef.value = target ?? null;
+}
+
+export function getTeleportTarget() {
+  return teleportTargetRef.value ?? undefined;
+}
+
+export function useTeleportTarget(
+  override?: MaybeRefOrGetter<TeleportTarget | null | undefined>,
+) {
+  // Composable version, ideal for `<Teleport :to="...">` bindings because the
+  // returned ref stays reactive to both global and local overrides.
+  return computed(() => {
+    const localTarget = override ? toValue(override) : undefined;
+    return localTarget ?? teleportTargetRef.value ?? undefined;
+  });
+}
+
+function resolveTargetElement(target?: TeleportTarget | null) {
+  if (typeof document === 'undefined') {
+    return null;
+  }
+
+  if (!target) {
+    return document.body;
+  }
+
+  if (typeof target === 'string') {
+    return document.querySelector(target) ?? document.body;
+  }
+
+  return target;
+}
+
+export function getTeleportContainer() {
+  // Immediate DOM resolver for imperative consumers (e.g., Toast manager)
+  // that simply need the concrete HTMLElement to append to right away.
+  return resolveTargetElement(teleportTargetRef.value);
+}