svelte-fluentui 1.3.0 → 1.3.1

package/README.md

@@ -2,6 +2,13 @@
 
 A comprehensive Svelte wrapper library for Microsoft FluentUI web components (v2.6.x), providing a seamless way to use FluentUI components in Svelte applications.
 
+## What's New in v1.3.1
+
+- **`Panel` — new `pinned` prop renders the panel as an inline `<aside>` instead of a portal'd overlay** — flips the rendering entirely: no portal, no backdrop, no transforms, no escape/outside-click handlers, `position: relative` so it participates in the parent's flex/grid layout, `align-self: stretch` so it fills its grid cell vertically. `open` is still respected so the panel can hide and let its grid cell collapse. Explicit z-index forms its own stacking context so overlay Panels opened on top still layer above as expected.
+- **`TopNav` — new `drawerPinned` + `drawerWidth` props turn the drawer into a permanent left rail with an always-visible hamburger toggle** — composes Panel's `pinned` so the same `drawerContent` snippet that renders the mobile overlay drawer also renders the desktop rail. `drawerWidth` (default `"280px"`) propagates to both modes. The hamburger stays visible when pinned so the user can collapse the rail back away, and an effect re-syncs the drawer's `open` state to `drawerPinned` on viewport flips (narrow→wide auto-opens, wide→narrow auto-closes).
+- **Docs layout switched to a single nav surface at every width via `drawerPinned`** — the duplicate desktop sidebar `GridItem` is gone; TopNav's drawer now renders as a pinned `<aside>` at ≥1024px and collapses to the hamburger overlay below. The layout uses CSS Grid with `grid-template-areas` and a `matchMedia` listener to drive `drawerPinned`. The pinned rail is `position: sticky` below the topnav and the scrollbar sits flush with the rail's inside edge.
+- **`TopNav` — tightened horizontal padding from `1.5rem` to `0.5rem`** — the bar's inside edges felt cramped relative to the rest of the content. Brand + hamburger now sit closer to the inline-start edge and the action slot sits closer to the inline-end edge.
+
 ## What's New in v1.3.0
 
 - **`Panel` — new slide-in side-panel primitive** — fixed-position, edge-anchored container with a single `children` slot and CSS-driven open/close transitions. Props cover physical sides (`left`/`right`), logical sides (`start`/`end` that follow RTL), `width`, `overlay`, `closeOnOutsideClick`, `closeOnEscape`, and a new `top` offset so the panel + overlay can sit below a sticky header (e.g. TopNav) and leave the trigger button clickable. Portals to `document.body` with direction captured before portal so locally-RTL wrappers still anchor correctly. First-class demo at `/components/navigation-layout/panel`.
@@ -11,15 +18,6 @@ A comprehensive Svelte wrapper library for Microsoft FluentUI web components (v2
 - **`Footer` — class namespaced as `.fluent-footer`, wired to the dedicated theme tokens, thin-strip bug fixed** — the rendered class went from generic `.footer` (collided with anything else using that name) to `.fluent-footer`, the rule now reads from `--fluent-footer-bg/text/border` (which were defined in the theme system but unused) with the previous neutral-layer values as fallback, a duplicate Blazor-port `.footer` rule was deleted, and `min-height: 48px` + `padding: 0.75rem 1rem` replaces the original horizontal-only padding so a default Footer is no longer a ~24px thin strip. First dedicated demo page at `/components/navigation-layout/footer`.
 - **Docs site dogfoods the new primitives** — the hand-rolled `<div class="topnav">` with ~90 lines of parallel CSS is replaced with `<TopNav class="docs-topnav" collapse="always">` using `brandTemplate` for the brand+version pair and `drawerContent` for the mobile sidebar nav. The sidebar nav is extracted into a single `{#snippet sidebarNav(closeDrawer)}` rendered both as the desktop sidebar and inside the TopNav drawer, with the sidebar/hamburger handoff at `lg` (1280px) instead of `md` so laptops at 1280×800 stay roomy. The footer at the bottom of every page now uses the three-part layout (© + MIT / attribution / GitHub + npm + version chip).
 
-## What's New in v1.2.0
-
-- **`Divider` — `orientation` and `role` props now forwarded** — the wrapper previously only exposed `class` and `style`, so vertical dividers and `role="presentation"` (for decorative separators that should be skipped by screen readers) weren't expressible through the Svelte API. `<fluent-divider>` natively supports both via fast-foundation; the wrapper just forwards them. Defaults preserved (`orientation="horizontal"`, `role="separator"`) so every existing call site renders identically. First proper demo page at `/components/divider` — the previous `/divider` route was an HMR sandbox and the components-list link to `/components/divider` was a 404.
-- **`Select` rewritten as a custom component** — the wrapped `<fluent-select>` rendered its dropdown listbox inside its own shadow DOM with a static `--max-height`, so inside Dialogs and other overflow-hidden ancestors the option list extended past the viewport with no scroll cutoff. New custom Select portals the listbox to `document.body` via `PositioningRegion` (Floating-UI), so it escapes any clipping ancestor and stays inside the viewport regardless of where the trigger sits. Full keyboard wiring (Arrow/Home/End/Enter/Space/Escape/Tab, single-char type-ahead with cycle-through-matches), multi-mode renders an always-expanded inline listbox matching FluentUI Blazor, and a hidden `<input>` keeps native form submission working. Public API mostly preserved; `value` widened to `string | string[]` for multi mode, `open` is now bindable, and `position` means "force placement" rather than the old static attribute.
-- **`PositioningRegion` — new `availableHeight` prop** — writes the computed remaining viewport height into the `--available-height` CSS custom property on the floating element on every reposition, so dropdowns can cap their max-height with `max-height: var(--available-height, <fallback>)` instead of hard-coding a value that overflows on small screens or near viewport edges. Works alongside `matchWidth` in a single `size()` middleware pass.
-- **`.fluent-value-label` — new canonical class for inline value labels next to a control** — separates field labels (the bold, stacked-above text that names a form field) from value labels (the inline text next to a single control that describes the value, e.g. "Remember me" next to a checkbox). Value labels are normal weight with a pointer cursor, matching FluentUI Blazor's pickers and `<fluent-radio>`'s slotted label. `data-disabled` / `data-readonly` on the wrapper drive a `not-allowed` cursor when the host is inactive.
-- **`Checkbox` & `Switch` — inline label fixes** — labels were rendering bold with a text cursor (using the field-label class) and clicks on the label didn't reliably toggle the control when no `id` was passed. Switched to the new `.fluent-value-label` class, and a stable per-instance `fallbackId` is now used as `<label for>` / element `id` when the caller didn't supply one, so label-click-to-toggle works regardless of whether an `id` was passed in. Applies across all three `labelPosition` values (`top` / `start` / `end`).
-- **`Select` & `Combobox` — field-label class consolidated to shared `.fluent-label`** — both components had component-scoped `.select-label` / `.combobox-label` rules that duplicated the canonical `.fluent-label` declarations from `assets/styles/components.scss`. A single library-wide tweak to label styling now lives in one place. After this change, every component that renders a stacked field label uses `.fluent-label`, Field uses its BEM-namespaced `fluent-field__label`, and Checkbox/Switch use `.fluent-value-label` — three classes total, each with a clear semantic role.
-
 ## Features
 
 - 🎨 **Complete FluentUI Component Set** - Wraps all major FluentUI web components

package/dist/components/layout/Panel.svelte

@@ -1,266 +1,311 @@
-<script lang="ts" module>
-	type PanelHandle = {
-		closeOnEscape: () => boolean
-		hide: () => void
-	}
-	const openPanelStack: PanelHandle[] = []
-	let escListenerAttached = false
-
-	function handleGlobalEscape(e: KeyboardEvent) {
-		if (e.key !== "Escape") return
-		const top = openPanelStack[openPanelStack.length - 1]
-		if (!top) return
-		if (!top.closeOnEscape()) return
-		e.preventDefault()
-		e.stopPropagation()
-		top.hide()
-	}
-
-	function pushPanel(handle: PanelHandle) {
-		openPanelStack.push(handle)
-		if (!escListenerAttached && typeof document !== "undefined") {
-			document.addEventListener("keydown", handleGlobalEscape, true)
-			escListenerAttached = true
-		}
-	}
-
-	function popPanel(handle: PanelHandle) {
-		const idx = openPanelStack.lastIndexOf(handle)
-		if (idx >= 0) openPanelStack.splice(idx, 1)
-		if (openPanelStack.length === 0 && escListenerAttached && typeof document !== "undefined") {
-			document.removeEventListener("keydown", handleGlobalEscape, true)
-			escListenerAttached = false
-		}
-	}
-</script>
-
-<script lang="ts">
-	import {onDestroy} from "svelte"
-	import type {SlotType} from "../../types/index.js"
-
-	type Side = "left" | "right" | "start" | "end"
-
-	type Props = {
-		open?: boolean
-		side?: Side
-		width?: string
-		top?: string
-		overlay?: boolean
-		closeOnOutsideClick?: boolean
-		closeOnEscape?: boolean
-		onclose?: () => void
-		children?: SlotType
-		class?: string
-		style?: string
-	}
-
-	let {
-		open = $bindable(false),
-		side = "right",
-		width = "320px",
-		top = "0",
-		overlay = true,
-		closeOnOutsideClick = true,
-		closeOnEscape = true,
-		onclose = undefined,
-		children = undefined,
-		class: className = undefined,
-		style = undefined
-	}: Props = $props()
-
-	let panelEl: HTMLElement | undefined = $state()
-	let isRTL = $state(false)
-
-	const handle: PanelHandle = {
-		closeOnEscape: () => closeOnEscape,
-		hide: () => close()
-	}
-
-	let wasOpen = false
-	$effect(() => {
-		if (open && !wasOpen) {
-			pushPanel(handle)
-			wasOpen = true
-		} else if (!open && wasOpen) {
-			popPanel(handle)
-			wasOpen = false
-		}
-	})
-
-	// Document-level outside-click detection — only needed when there's no
-	// overlay to catch the click. Deferred to the next task so the same click
-	// that opened the panel doesn't immediately close it.
-	$effect(() => {
-		if (!open || overlay || !closeOnOutsideClick) return
-		const id = setTimeout(() => {
-			document.addEventListener("pointerdown", handleOutsideClick, true)
-		}, 0)
-		return () => {
-			clearTimeout(id)
-			document.removeEventListener("pointerdown", handleOutsideClick, true)
-		}
-	})
-
-	function handleOutsideClick(e: PointerEvent) {
-		if (!panelEl) return
-		if (panelEl.contains(e.target as Node)) return
-		close()
-	}
-
-	onDestroy(() => {
-		if (wasOpen) popPanel(handle)
-	})
-
-	function close() {
-		open = false
-		onclose?.()
-	}
-
-	function onOverlayClick() {
-		if (closeOnOutsideClick) close()
-	}
-
-	// Combined: capture the original parent's direction BEFORE moving the node
-	// under <body>. Doing both in one action avoids relying on Svelte's
-	// multi-action source-order. We set `dir="rtl"` (so `inset-inline-*`
-	// resolves correctly) AND flip an isRTL flag (so a class-based selector can
-	// drive the rest of the styling without depending on attribute matching).
-	function setupRoot(node: HTMLElement) {
-		const parent = node.parentElement
-		if (parent && getComputedStyle(parent).direction === "rtl") {
-			node.setAttribute("dir", "rtl")
-			isRTL = true
-		}
-		document.body.appendChild(node)
-		return {
-			destroy() {
-				node.parentNode?.removeChild(node)
-			}
-		}
-	}
-</script>
-
-<div
-	class="fluent-panel-root fluent-panel-root--{side} {className || ''}"
-	class:fluent-panel-root--open={open}
-	class:fluent-panel-root--rtl={isRTL}
-	style="--panel-top: {top};"
-	aria-hidden={!open}
-	use:setupRoot
->
-	{#if overlay}
-		<div
-			class="fluent-panel-overlay"
-			role="button"
-			tabindex={-1}
-			aria-label="Close panel"
-			onclick={onOverlayClick}
-			onkeydown={(e) => (e.key === "Enter" || e.key === " ") && onOverlayClick()}
-		></div>
-	{/if}
-
-	<div
-		bind:this={panelEl}
-		class="fluent-panel"
-		role="dialog"
-		aria-modal={overlay}
-		style="width: {width}; {style || ''}"
-	>
-		{@render children?.()}
-	</div>
-</div>
-
-<style lang="scss">
-	.fluent-panel-root {
-		position: fixed;
-		top: var(--panel-top, 0);
-		right: 0;
-		bottom: 0;
-		left: 0;
-		z-index: var(--fluent-z-modal, 1050);
-		// Never block the page — only the overlay and the panel surface
-		// (re-enabled below) capture pointer events.
-		pointer-events: none;
-	}
-
-	.fluent-panel-overlay {
-		position: absolute;
-		inset: 0;
-		background-color: rgba(0, 0, 0, 0);
-		cursor: pointer;
-		pointer-events: none;
-		transition: background-color 0.25s ease;
-		z-index: var(--fluent-z-modal-backdrop, 1040);
-	}
-
-	.fluent-panel {
-		position: absolute;
-		top: 0;
-		height: 100%;
-		max-width: 90vw;
-		background-color: var(--neutral-layer-1, #ffffff);
-		display: flex;
-		flex-direction: column;
-		overflow: hidden;
-		pointer-events: none;
-		transition: transform 0.25s ease, visibility 0.25s ease;
-		visibility: hidden;
-		z-index: calc(var(--fluent-z-modal, 1050) + 1);
-	}
-
-	// Closed-state per-side transforms — declared BEFORE the --open rule so
-	// the open rule wins on source order at equal specificity.
-
-	// Physical sides — never flip with direction.
-	.fluent-panel-root--right .fluent-panel {
-		right: 0;
-		box-shadow: -4px 0 16px rgba(0, 0, 0, 0.15);
-		transform: translateX(100%);
-	}
-
-	.fluent-panel-root--left .fluent-panel {
-		left: 0;
-		box-shadow: 4px 0 16px rgba(0, 0, 0, 0.15);
-		transform: translateX(-100%);
-	}
-
-	// Logical sides — follow the writing direction (start = left in LTR, right in RTL).
-	.fluent-panel-root--start .fluent-panel {
-		inset-inline-start: 0;
-		box-shadow: 4px 0 16px rgba(0, 0, 0, 0.15);
-		transform: translateX(-100%);
-	}
-
-	.fluent-panel-root--start.fluent-panel-root--rtl .fluent-panel {
-		inset-inline-start: unset;
-		right: 0;
-		box-shadow: -4px 0 16px rgba(0, 0, 0, 0.15);
-		transform: translateX(100%);
-	}
-
-	.fluent-panel-root--end .fluent-panel {
-		inset-inline-end: 0;
-		box-shadow: -4px 0 16px rgba(0, 0, 0, 0.15);
-		transform: translateX(100%);
-	}
-
-	.fluent-panel-root--end.fluent-panel-root--rtl .fluent-panel {
-		inset-inline-end: unset;
-		left: 0;
-		box-shadow: 4px 0 16px rgba(0, 0, 0, 0.15);
-		transform: translateX(-100%);
-	}
-
-	.fluent-panel-root--open .fluent-panel-overlay {
-		background-color: rgba(0, 0, 0, 0.3);
-		pointer-events: auto;
-	}
-
-	// Match the (0,3,0) specificity of the RTL side overrides so the open
-	// transform wins on source order (this rule is last).
-	.fluent-panel-root.fluent-panel-root--open .fluent-panel {
-		transform: translateX(0);
-		visibility: visible;
-		pointer-events: auto;
-	}
-</style>
+<script lang="ts" module>
+	type PanelHandle = {
+		closeOnEscape: () => boolean
+		hide: () => void
+	}
+	const openPanelStack: PanelHandle[] = []
+	let escListenerAttached = false
+
+	function handleGlobalEscape(e: KeyboardEvent) {
+		if (e.key !== "Escape") return
+		const top = openPanelStack[openPanelStack.length - 1]
+		if (!top) return
+		if (!top.closeOnEscape()) return
+		e.preventDefault()
+		e.stopPropagation()
+		top.hide()
+	}
+
+	function pushPanel(handle: PanelHandle) {
+		openPanelStack.push(handle)
+		if (!escListenerAttached && typeof document !== "undefined") {
+			document.addEventListener("keydown", handleGlobalEscape, true)
+			escListenerAttached = true
+		}
+	}
+
+	function popPanel(handle: PanelHandle) {
+		const idx = openPanelStack.lastIndexOf(handle)
+		if (idx >= 0) openPanelStack.splice(idx, 1)
+		if (openPanelStack.length === 0 && escListenerAttached && typeof document !== "undefined") {
+			document.removeEventListener("keydown", handleGlobalEscape, true)
+			escListenerAttached = false
+		}
+	}
+</script>
+
+<script lang="ts">
+	import {onDestroy} from "svelte"
+	import type {SlotType} from "../../types/index.js"
+
+	type Side = "left" | "right" | "start" | "end"
+
+	type Props = {
+		open?: boolean
+		side?: Side
+		width?: string
+		top?: string
+		overlay?: boolean
+		closeOnOutsideClick?: boolean
+		closeOnEscape?: boolean
+		pinned?: boolean
+		onclose?: () => void
+		children?: SlotType
+		class?: string
+		style?: string
+	}
+
+	let {
+		open = $bindable(false),
+		side = "right",
+		width = "320px",
+		top = "0",
+		overlay = true,
+		closeOnOutsideClick = true,
+		closeOnEscape = true,
+		pinned = false,
+		onclose = undefined,
+		children = undefined,
+		class: className = undefined,
+		style = undefined
+	}: Props = $props()
+
+	let panelEl: HTMLElement | undefined = $state()
+	let isRTL = $state(false)
+
+	const handle: PanelHandle = {
+		closeOnEscape: () => closeOnEscape,
+		hide: () => close()
+	}
+
+	let wasOpen = false
+	$effect(() => {
+		if (pinned) return
+		if (open && !wasOpen) {
+			pushPanel(handle)
+			wasOpen = true
+		} else if (!open && wasOpen) {
+			popPanel(handle)
+			wasOpen = false
+		}
+	})
+
+	// Document-level outside-click detection — only needed when there's no
+	// overlay to catch the click. Deferred to the next task so the same click
+	// that opened the panel doesn't immediately close it.
+	$effect(() => {
+		if (pinned || !open || overlay || !closeOnOutsideClick) return
+		const id = setTimeout(() => {
+			document.addEventListener("pointerdown", handleOutsideClick, true)
+		}, 0)
+		return () => {
+			clearTimeout(id)
+			document.removeEventListener("pointerdown", handleOutsideClick, true)
+		}
+	})
+
+	function handleOutsideClick(e: PointerEvent) {
+		if (!panelEl) return
+		if (panelEl.contains(e.target as Node)) return
+		close()
+	}
+
+	onDestroy(() => {
+		if (wasOpen) popPanel(handle)
+	})
+
+	function close() {
+		open = false
+		onclose?.()
+	}
+
+	function onOverlayClick() {
+		if (closeOnOutsideClick) close()
+	}
+
+	// Combined: capture the original parent's direction BEFORE moving the node
+	// under <body>. Doing both in one action avoids relying on Svelte's
+	// multi-action source-order. We set `dir="rtl"` (so `inset-inline-*`
+	// resolves correctly) AND flip an isRTL flag (so a class-based selector can
+	// drive the rest of the styling without depending on attribute matching).
+	function setupRoot(node: HTMLElement) {
+		const parent = node.parentElement
+		if (parent && getComputedStyle(parent).direction === "rtl") {
+			node.setAttribute("dir", "rtl")
+			isRTL = true
+		}
+		document.body.appendChild(node)
+		return {
+			destroy() {
+				node.parentNode?.removeChild(node)
+			}
+		}
+	}
+</script>
+
+{#if pinned}
+	{#if open}
+		<aside
+			class="fluent-panel fluent-panel--pinned fluent-panel--pinned-{side} {className || ''}"
+			style="width: {width}; {style || ''}"
+		>
+			{@render children?.()}
+		</aside>
+	{/if}
+{:else}
+	<div
+		class="fluent-panel-root fluent-panel-root--{side} {className || ''}"
+		class:fluent-panel-root--open={open}
+		class:fluent-panel-root--rtl={isRTL}
+		style="--panel-top: {top};"
+		aria-hidden={!open}
+		use:setupRoot
+	>
+		{#if overlay}
+			<div
+				class="fluent-panel-overlay"
+				role="button"
+				tabindex={-1}
+				aria-label="Close panel"
+				onclick={onOverlayClick}
+				onkeydown={(e) => (e.key === "Enter" || e.key === " ") && onOverlayClick()}
+			></div>
+		{/if}
+
+		<div
+			bind:this={panelEl}
+			class="fluent-panel"
+			role="dialog"
+			aria-modal={overlay}
+			style="width: {width}; {style || ''}"
+		>
+			{@render children?.()}
+		</div>
+	</div>
+{/if}
+
+<style lang="scss">
+	.fluent-panel-root {
+		position: fixed;
+		top: var(--panel-top, 0);
+		right: 0;
+		bottom: 0;
+		left: 0;
+		z-index: var(--fluent-z-modal, 1050);
+		// Never block the page — only the overlay and the panel surface
+		// (re-enabled below) capture pointer events.
+		pointer-events: none;
+	}
+
+	.fluent-panel-overlay {
+		position: absolute;
+		inset: 0;
+		background-color: rgba(0, 0, 0, 0);
+		cursor: pointer;
+		pointer-events: none;
+		transition: background-color 0.25s ease;
+		z-index: var(--fluent-z-modal-backdrop, 1040);
+	}
+
+	.fluent-panel {
+		position: absolute;
+		top: 0;
+		height: 100%;
+		max-width: 90vw;
+		background-color: var(--neutral-layer-1, #ffffff);
+		display: flex;
+		flex-direction: column;
+		overflow: hidden;
+		pointer-events: none;
+		transition: transform 0.25s ease, visibility 0.25s ease;
+		visibility: hidden;
+		z-index: calc(var(--fluent-z-modal, 1050) + 1);
+	}
+
+	// Closed-state per-side transforms — declared BEFORE the --open rule so
+	// the open rule wins on source order at equal specificity.
+
+	// Physical sides — never flip with direction.
+	.fluent-panel-root--right .fluent-panel {
+		right: 0;
+		box-shadow: -4px 0 16px rgba(0, 0, 0, 0.15);
+		transform: translateX(100%);
+	}
+
+	.fluent-panel-root--left .fluent-panel {
+		left: 0;
+		box-shadow: 4px 0 16px rgba(0, 0, 0, 0.15);
+		transform: translateX(-100%);
+	}
+
+	// Logical sides — follow the writing direction (start = left in LTR, right in RTL).
+	.fluent-panel-root--start .fluent-panel {
+		inset-inline-start: 0;
+		box-shadow: 4px 0 16px rgba(0, 0, 0, 0.15);
+		transform: translateX(-100%);
+	}
+
+	.fluent-panel-root--start.fluent-panel-root--rtl .fluent-panel {
+		inset-inline-start: unset;
+		right: 0;
+		box-shadow: -4px 0 16px rgba(0, 0, 0, 0.15);
+		transform: translateX(100%);
+	}
+
+	.fluent-panel-root--end .fluent-panel {
+		inset-inline-end: 0;
+		box-shadow: -4px 0 16px rgba(0, 0, 0, 0.15);
+		transform: translateX(100%);
+	}
+
+	.fluent-panel-root--end.fluent-panel-root--rtl .fluent-panel {
+		inset-inline-end: unset;
+		left: 0;
+		box-shadow: 4px 0 16px rgba(0, 0, 0, 0.15);
+		transform: translateX(-100%);
+	}
+
+	.fluent-panel-root--open .fluent-panel-overlay {
+		background-color: rgba(0, 0, 0, 0.3);
+		pointer-events: auto;
+	}
+
+	// Match the (0,3,0) specificity of the RTL side overrides so the open
+	// transform wins on source order (this rule is last).
+	.fluent-panel-root.fluent-panel-root--open .fluent-panel {
+		transform: translateX(0);
+		visibility: visible;
+		pointer-events: auto;
+	}
+
+	// Pinned: render in normal flow as a regular column. None of the
+	// floating-panel positioning, transforms, or visibility gymnastics apply
+	// — caller is responsible for placing the <aside> via parent layout.
+	//
+	// `z-index` is explicit (not auto) so pinned forms its own stacking
+	// context — keeps overlay drawers (z-index 1050+) and their backdrops
+	// (1040) reliably above any pinned drawer, regardless of paint order.
+	// Override via --fluent-z-panel-pinned on the consumer side if multiple
+	// pinned panels need to layer relative to each other.
+	.fluent-panel--pinned {
+		position: relative;
+		top: auto;
+		height: auto;
+		max-width: none;
+		transform: none;
+		visibility: visible;
+		pointer-events: auto;
+		transition: none;
+		flex-shrink: 0;
+		align-self: stretch;
+		box-shadow: none;
+		border-inline-end: 1px solid var(--neutral-stroke-layer-rest, #e0e0e0);
+		z-index: var(--fluent-z-panel-pinned, 1);
+	}
+
+	.fluent-panel--pinned-end,
+	.fluent-panel--pinned-right {
+		border-inline-end: none;
+		border-inline-start: 1px solid var(--neutral-stroke-layer-rest, #e0e0e0);
+	}
+</style>

package/dist/components/layout/Panel.svelte.d.ts

@@ -8,6 +8,7 @@ type Props = {
     overlay?: boolean;
     closeOnOutsideClick?: boolean;
     closeOnEscape?: boolean;
+    pinned?: boolean;
     onclose?: () => void;
     children?: SlotType;
     class?: string;