winui-svelte 0.0.3 → 0.0.5

package/src/window/anchor.ts

@@ -0,0 +1,156 @@
+/**
+ * A corner of a window or of a display's work area. A window that changes
+ * size keeps its anchor corner where it is; a window docked to an anchor sits
+ * against that corner.
+ */
+export const WindowAnchor = {
+  topLeft: "topLeft",
+  topRight: "topRight",
+  bottomLeft: "bottomLeft",
+  bottomRight: "bottomRight"
+} as const;
+
+/** One of `WindowAnchor`'s values. */
+export type WindowAnchor = (typeof WindowAnchor)[keyof typeof WindowAnchor];
+
+/**
+ * Which of a window's sides follow its content: the width, the height, both,
+ * or neither (the window keeps the size its props and its user give it).
+ */
+export const SizeToContent = {
+  none: "none",
+  width: "width",
+  height: "height",
+  both: "both"
+} as const;
+
+/** One of `SizeToContent`'s values. */
+export type SizeToContent = (typeof SizeToContent)[keyof typeof SizeToContent];
+
+/** A position and a size in device pixels, as AppWindow and DisplayArea have them. */
+export interface WindowBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/** A size in device pixels. */
+export interface WindowSize {
+  width: number;
+  height: number;
+}
+
+/** The least and the most a window may be, in device pixels; `Infinity` is no most. */
+export interface WindowLimits {
+  minWidth: number;
+  minHeight: number;
+  maxWidth: number;
+  maxHeight: number;
+}
+
+const ANCHOR_SIDES = {
+  [WindowAnchor.topLeft]: {
+    isRight: false,
+    isBottom: false
+  },
+  [WindowAnchor.topRight]: {
+    isRight: true,
+    isBottom: false
+  },
+  [WindowAnchor.bottomLeft]: {
+    isRight: false,
+    isBottom: true
+  },
+  [WindowAnchor.bottomRight]: {
+    isRight: true,
+    isBottom: true
+  }
+} as const satisfies Record<WindowAnchor, {
+  isRight: boolean;
+  isBottom: boolean;
+}>;
+
+/**
+ * The window `bounds` at `size` with its `anchor` corner where it was: a
+ * window anchored bottom-right that grows taller grows upward.
+ */
+export function anchoredBounds({ bounds, size, anchor }: {
+  bounds: WindowBounds;
+  size: WindowSize;
+  anchor: WindowAnchor;
+}) {
+  const { isRight, isBottom } = ANCHOR_SIDES[anchor];
+  return {
+    x: isRight ? bounds.x + bounds.width - size.width : bounds.x,
+    y: isBottom ? bounds.y + bounds.height - size.height : bounds.y,
+    width: size.width,
+    height: size.height
+  };
+}
+
+/**
+ * Where a window of `size` sits against the `anchor` corner of `area` (a
+ * display's work area), `inset` device pixels in from both of its edges.
+ */
+export function dockedBounds({ area, size, anchor, inset }: {
+  area: WindowBounds;
+  size: WindowSize;
+  anchor: WindowAnchor;
+  inset: number;
+}) {
+  const { isRight, isBottom } = ANCHOR_SIDES[anchor];
+  return {
+    x: isRight ? area.x + area.width - size.width - inset : area.x + inset,
+    y: isBottom ? area.y + area.height - size.height - inset : area.y + inset,
+    width: size.width,
+    height: size.height
+  };
+}
+
+function clamp({ value, least, most }: {
+  value: number;
+  least: number;
+  most: number;
+}) {
+  return Math.min(Math.max(value, least), most);
+}
+
+/**
+ * The bounds a window sized to its content takes: the sides `mode` names go to
+ * `desired` (what the content asks for, frame included) within `limits`, and
+ * the `anchor` corner stays. null when the window is already that size, so a
+ * caller makes no call for it.
+ */
+export function fittedBounds({ bounds, desired, mode, anchor, limits }: {
+  bounds: WindowBounds;
+  desired: WindowSize;
+  mode: SizeToContent;
+  anchor: WindowAnchor;
+  limits: WindowLimits;
+}) {
+  const isWidthFitted = mode === SizeToContent.width || mode === SizeToContent.both;
+  const isHeightFitted = mode === SizeToContent.height || mode === SizeToContent.both;
+  const size = {
+    width: isWidthFitted ? clamp({
+      value: desired.width,
+      least: limits.minWidth,
+      most: limits.maxWidth
+    }) : bounds.width,
+    height: isHeightFitted ? clamp({
+      value: desired.height,
+      least: limits.minHeight,
+      most: limits.maxHeight
+    }) : bounds.height
+  };
+  const isUnchanged = size.width === bounds.width && size.height === bounds.height;
+  if (isUnchanged) {
+    return null;
+  }
+
+  return anchoredBounds({
+    bounds,
+    size,
+    anchor
+  });
+}

package/src/window/apply-chrome.ts

@@ -2,6 +2,7 @@ import { isBackgroundRun } from "./background-mode.ts";
 import type { CaptionButtonColors, CaptionButtonProperty } from "./chrome.ts";
 import {
   captionButtonChanges,
+  IconShowOptions,
   scaledRegion,
   TitleBarHeight,
   WindowPresentation,
@@ -15,6 +16,7 @@ import {
   ElementTheme,
   InputNonClientPointerSource,
   TitleBarHeightOption,
+  TitleBarIconShowOptions,
   TitleBarTheme
 } from "#src/winui.js";
 
@@ -38,12 +40,25 @@ const TITLE_BAR_HEIGHTS = {
   [TitleBarHeight.tall]: TitleBarHeightOption.Tall
 } as const satisfies Record<TitleBarHeight, TitleBarHeightOption>;
 
+const ICON_SHOW_OPTIONS = {
+  [IconShowOptions.showIconAndSystemMenu]: TitleBarIconShowOptions.ShowIconAndSystemMenu,
+  [IconShowOptions.hideIconAndSystemMenu]: TitleBarIconShowOptions.HideIconAndSystemMenu
+} as const satisfies Record<IconShowOptions, TitleBarIconShowOptions>;
+
 const PRESENTER_KINDS = {
   [WindowPresentation.windowed]: AppWindowPresenterKind.Overlapped,
   [WindowPresentation.fullScreen]: AppWindowPresenterKind.FullScreen,
   [WindowPresentation.compactOverlay]: AppWindowPresenterKind.CompactOverlay
 } as const satisfies Record<WindowPresentation, AppWindowPresenterKind>;
 
+/** Shows or hides the window's icon and system menu in the title bar. */
+export function applyIconShowOptions({ appWindow, options }: {
+  appWindow: AppWindow;
+  options: IconShowOptions;
+}) {
+  appWindow.titleBar.iconShowOptions = ICON_SHOW_OPTIONS[options];
+}
+
 /**
  * Presents the window as `presentation`. Back to windowed it is a new
  * overlapped presenter, with none of the limits set on the last one.
@@ -55,6 +70,13 @@ export function applyPresentation({ appWindow, presentation }: {
   appWindow.setPresenterByKind(PRESENTER_KINDS[presentation]);
 }
 
+/** The presentation the window has now, read back from its presenter. */
+export function presentationOf(appWindow: AppWindow) {
+  const { kind } = appWindow.presenter;
+  const found = Object.values(WindowPresentation).find(presentation => PRESENTER_KINDS[presentation] === kind);
+  return found ?? WindowPresentation.windowed;
+}
+
 /** Makes the content, and the caption buttons, light or dark, or the system's. */
 export function applyTheme({ appWindow, content, theme }: {
   appWindow: AppWindow;

package/src/window/backdrop.ts

@@ -1,4 +1,5 @@
 import { AcrylicVariant, attachAcrylic } from "./acrylic-controller.ts";
+import { attachTransparentBackdrop } from "./transparent-backdrop.ts";
 import { write } from "#src/renderer/host/reflect.js";
 import type { FrameworkElement, Window } from "#src/winui.js";
 import { DesktopAcrylicBackdrop, MicaBackdrop, MicaKind } from "#src/winui.js";
@@ -7,7 +8,9 @@ import { DesktopAcrylicBackdrop, MicaBackdrop, MicaKind } from "#src/winui.js";
  * The material behind a window's content. Acrylic blurs and tints what is
  * behind the window (`acrylicBase` and `acrylicThin` are its other two
  * variants, made by the system backdrop controller); Mica tints with the desktop wallpaper (Mica Alt more
- * strongly, as a tabbed title bar has it); none leaves the theme's solid color.
+ * strongly, as a tabbed title bar has it); transparent shows the desktop
+ * through every pixel the content leaves clear (with per-pixel alpha; pair it
+ * with `isBorderless`); none leaves the theme's solid color.
  */
 export const Backdrop = {
   acrylic: "acrylic",
@@ -15,7 +18,8 @@ export const Backdrop = {
   acrylicThin: "acrylicThin",
   mica: "mica",
   micaAlt: "micaAlt",
-  none: "none"
+  none: "none",
+  transparent: "transparent"
 } as const;
 
 /** One of `Backdrop`'s values. */
@@ -64,6 +68,7 @@ export function applyBackdrop({ window, content, backdrop }: {
 }) {
   const variant = controllerVariants.get(backdrop);
   const isControlled = variant !== undefined;
+  const isTransparent = backdrop === Backdrop.transparent;
   const systemBackdrop = isControlled ? null : systemBackdropFor(backdrop);
   const isRemoved = systemBackdrop === null;
   if (isRemoved) {
@@ -74,6 +79,10 @@ export function applyBackdrop({ window, content, backdrop }: {
     window.systemBackdrop = systemBackdrop;
   }
 
+  if (isTransparent) {
+    return attachTransparentBackdrop(window);
+  }
+
   if (isControlled) {
     return attachAcrylic({
       window,

package/src/window/badge-icon.ts

@@ -0,0 +1,234 @@
+import { BadgeGlyph } from "#src/web-apis/badge-glyph.js";
+import { BYTES_PER_PIXEL, pixelBytes } from "#src/win32-icons.js";
+
+// Draws the badge of `navigator.setAppBadge` as pixels, for the taskbar
+// overlay icon Windows is not asked to draw (the toast badge is drawn by
+// Windows itself, and only for an app with package identity). The glyph set is
+// the toast badge's own (`BadgeGlyph`), so both read from one list.
+
+const MAX_LABEL_COUNT = 99;
+const OVERFLOW_LABEL = "99+";
+const GLYPH_SCALE_HEIGHT = 0.7;
+const GLYPH_SCALE_WIDTH = 0.75;
+const EDGE_SOFTNESS = 1;
+const MARK_ROWS = 5;
+const DIGIT_COLUMNS = 3;
+const MARK_COLUMNS = 5;
+const DIGIT_GAP = 1;
+const CENTER = 0.5;
+const OPAQUE = 255;
+const ALPHA_OFFSET = 3;
+
+// Colors as hex text, read into bytes when a badge is drawn.
+type Rgb = string;
+
+const WHITE: Rgb = "ffffff";
+const RED: Rgb = "c42b1c";
+const GREEN: Rgb = "0f7b0f";
+const AMBER: Rgb = "9d5d00";
+const BLUE: Rgb = "0067c0";
+const GREY: Rgb = "606060";
+
+/** The shapes drawn in white on a glyph's disc. */
+const Mark = {
+  DOT: "dot",
+  BANG: "bang",
+  CHECK: "check",
+  CROSS: "cross",
+  PLAY: "play",
+  PAUSE: "pause"
+} as const;
+type Mark = (typeof Mark)[keyof typeof Mark];
+
+const MARKS: Record<Mark, readonly string[]> = {
+  [Mark.DOT]: ["00000", "01110", "01110", "01110", "00000"],
+  [Mark.BANG]: ["00100", "00100", "00100", "00000", "00100"],
+  [Mark.CHECK]: ["00000", "00001", "10010", "01100", "00000"],
+  [Mark.CROSS]: ["10001", "01010", "00100", "01010", "10001"],
+  [Mark.PLAY]: ["01000", "01100", "01110", "01100", "01000"],
+  [Mark.PAUSE]: ["01010", "01010", "01010", "01010", "01010"]
+};
+
+// Three columns by five rows, one string per row, "1" lit.
+const DIGITS: Record<string, readonly string[]> = {
+  0: ["111", "101", "101", "101", "111"],
+  1: ["010", "110", "010", "010", "111"],
+  2: ["111", "001", "111", "100", "111"],
+  3: ["111", "001", "111", "001", "111"],
+  4: ["101", "101", "111", "001", "001"],
+  5: ["111", "100", "111", "001", "111"],
+  6: ["111", "100", "111", "101", "111"],
+  7: ["111", "001", "010", "010", "010"],
+  8: ["111", "101", "111", "101", "111"],
+  9: ["111", "101", "111", "001", "111"],
+  "+": ["000", "010", "111", "010", "000"]
+};
+
+const GLYPH_LOOKS: Record<Exclude<BadgeGlyph, typeof BadgeGlyph.NONE>, {
+  readonly color: Rgb;
+  readonly mark: Mark;
+}> = {
+  [BadgeGlyph.ACTIVITY]: {
+    color: BLUE,
+    mark: Mark.DOT
+  },
+  [BadgeGlyph.ALARM]: {
+    color: AMBER,
+    mark: Mark.BANG
+  },
+  [BadgeGlyph.ALERT]: {
+    color: RED,
+    mark: Mark.BANG
+  },
+  [BadgeGlyph.ATTENTION]: {
+    color: RED,
+    mark: Mark.BANG
+  },
+  [BadgeGlyph.AVAILABLE]: {
+    color: GREEN,
+    mark: Mark.CHECK
+  },
+  [BadgeGlyph.AWAY]: {
+    color: AMBER,
+    mark: Mark.DOT
+  },
+  [BadgeGlyph.BUSY]: {
+    color: RED,
+    mark: Mark.DOT
+  },
+  [BadgeGlyph.ERROR]: {
+    color: RED,
+    mark: Mark.CROSS
+  },
+  [BadgeGlyph.NEW_MESSAGE]: {
+    color: BLUE,
+    mark: Mark.BANG
+  },
+  [BadgeGlyph.PAUSED]: {
+    color: GREY,
+    mark: Mark.PAUSE
+  },
+  [BadgeGlyph.PLAYING]: {
+    color: GREEN,
+    mark: Mark.PLAY
+  },
+  [BadgeGlyph.UNAVAILABLE]: {
+    color: GREY,
+    mark: Mark.CROSS
+  }
+};
+
+/** What a badge shows: a count (red disc) or a status glyph. */
+export type BadgeFace = {
+  readonly count: number;
+} | {
+  readonly glyph: Exclude<BadgeGlyph, typeof BadgeGlyph.NONE>;
+};
+
+/**
+ * The text a count badge shows: the number, or "99+" above 99.
+ *
+ * @param count - A positive integer.
+ * @returns The label.
+ */
+export function badgeLabel(count: number) {
+  return count > MAX_LABEL_COUNT ? OVERFLOW_LABEL : String(count);
+}
+
+/**
+ * What the screen reader says for the badge, which is also the overlay icon's
+ * accessibility description.
+ *
+ * @param face - The count or the glyph.
+ * @returns The description.
+ */
+export function badgeDescription(face: BadgeFace) {
+  return "count" in face ? `${badgeLabel(face.count)} unread` : face.glyph;
+}
+
+function bitmapOf({ face }: {
+  face: BadgeFace;
+}) {
+  const isCount = "count" in face;
+  if (isCount) {
+    const rows = Array.from({ length: MARK_ROWS }, () => "");
+    const characters = badgeLabel(face.count).split("");
+    for (const [iCharacter, character] of characters.entries()) {
+      const glyphRows = DIGITS[character] ?? [];
+      const gap = iCharacter === 0 ? "" : "0".repeat(DIGIT_GAP);
+      for (const [iRow, row] of glyphRows.entries()) {
+        rows[iRow] = `${rows[iRow] ?? ""}${gap}${row}`;
+      }
+    }
+
+    return {
+      rows,
+      color: RED
+    };
+  }
+
+  const look = GLYPH_LOOKS[face.glyph];
+  return {
+    rows: MARKS[look.mark],
+    color: look.color
+  };
+}
+
+function isLit({ rows, column, row }: {
+  rows: readonly string[];
+  column: number;
+  row: number;
+}) {
+  return rows[row]?.[column] === "1";
+}
+
+/**
+ * Draws a badge as a square icon: a disc with the count or the glyph's mark in
+ * white, anti-aliased on the rim, clear outside the disc.
+ *
+ * @param options - The pixels per side and what to show.
+ * @returns The pixels, blue first, with straight alpha.
+ */
+export function renderBadgeIcon({ size, face }: {
+  size: number;
+  face: BadgeFace;
+}) {
+  const { rows, color } = bitmapOf({ face });
+  const columns = rows[0]?.length ?? DIGIT_COLUMNS;
+  const isGlyph = !("count" in face);
+  const fitColumns = isGlyph ? MARK_COLUMNS : columns;
+  const byHeight = Math.floor((size * GLYPH_SCALE_HEIGHT) / MARK_ROWS);
+  const byWidth = Math.floor((size * GLYPH_SCALE_WIDTH) / fitColumns);
+  const scale = Math.max(1, Math.min(byHeight, byWidth));
+  const left = Math.floor((size - columns * scale) / 2);
+  const top = Math.floor((size - MARK_ROWS * scale) / 2);
+  const radius = size / 2;
+  const bgra = new Uint8Array(pixelBytes(size));
+  const disc = Buffer.from(color, "hex");
+  const ink = Buffer.from(WHITE, "hex");
+  for (let y = 0; y < size; y += 1) {
+    for (let x = 0; x < size; x += 1) {
+      const distance = Math.hypot(x + CENTER - radius, y + CENTER - radius);
+      const coverage = Math.min(1, Math.max(0, (radius - distance) / EDGE_SOFTNESS));
+      const column = Math.floor((x - left) / scale);
+      const row = Math.floor((y - top) / scale);
+      const isInk = x >= left && y >= top && isLit({
+        rows,
+        column,
+        row
+      });
+
+      const [red = 0, green = 0, blue = 0] = isInk ? ink : disc;
+      const offset = (y * size + x) * BYTES_PER_PIXEL;
+      bgra[offset] = blue;
+      bgra[offset + 1] = green;
+      bgra[offset + 2] = red;
+      bgra[offset + ALPHA_OFFSET] = Math.round(coverage * OPAQUE);
+    }
+  }
+
+  return {
+    size,
+    bgra
+  };
+}

package/src/window/chrome.ts

@@ -30,6 +30,18 @@ export const TitleBarHeight = {
 /** One of `TitleBarHeight`'s values. */
 export type TitleBarHeight = (typeof TitleBarHeight)[keyof typeof TitleBarHeight];
 
+/**
+ * Whether the title bar shows the window's icon (and opens the system menu on
+ * a click on it): the icon and menu are shown by default.
+ */
+export const IconShowOptions = {
+  showIconAndSystemMenu: "showIconAndSystemMenu",
+  hideIconAndSystemMenu: "hideIconAndSystemMenu"
+} as const;
+
+/** One of `IconShowOptions`' values. */
+export type IconShowOptions = (typeof IconShowOptions)[keyof typeof IconShowOptions];
+
 /**
  * How a window is presented: in its frame (windowed, the default), over the
  * whole display (fullScreen), or as a small always-on-top window

package/src/window/create-window.ts

@@ -21,6 +21,8 @@ interface WindowChrome extends Pick<
   | "isShownInSwitchers"
   | "isToolWindow"
   | "owner"
+  | "anchor"
+  | "sizeToContent"
   | "title"
 > {
   /** In device pixels. */
@@ -123,7 +125,9 @@ export function createWindow<Props extends object>(options: WindowOptions<Props>
       isExcludedFromCapture: options.isExcludedFromCapture,
       isHidden: options.isHidden,
       isShownInSwitchers: options.isShownInSwitchers,
-      isToolWindow: options.isToolWindow
+      isToolWindow: options.isToolWindow,
+      sizeToContent: options.sizeToContent,
+      anchor: options.anchor
     },
     titleBar: () => null,
     size: options.size

package/src/window/css-pixels.ts

@@ -0,0 +1,18 @@
+/**
+ * Device-independent pixels (what the web calls CSS pixels) as device pixels,
+ * at `scale` device pixels per device-independent pixel.
+ */
+export function toDevicePixels({ value, scale }: {
+  value: number;
+  scale: number;
+}) {
+  return Math.round(value * scale);
+}
+
+/** Device pixels as device-independent (CSS) pixels, at `scale` device pixels per one. */
+export function toCssPixels({ value, scale }: {
+  value: number;
+  scale: number;
+}) {
+  return Math.round(value / scale);
+}

package/src/window/dock.ts

@@ -0,0 +1,99 @@
+import type { WindowAnchor } from "./anchor.ts";
+import { dockedBounds } from "./anchor.ts";
+import { foregroundWindowHandle } from "./native.ts";
+import type { AppWindow } from "#src/winui.js";
+import { DisplayArea, DisplayAreaFallback } from "#src/winui.js";
+
+/**
+ * Which display a window is docked to: the one the user is working on (the
+ * foreground window's), the one the window is on, or the primary one.
+ */
+export const DockDisplay = {
+  active: "active",
+  current: "current",
+  primary: "primary"
+} as const;
+
+/** One of `DockDisplay`'s values. */
+export type DockDisplay = (typeof DockDisplay)[keyof typeof DockDisplay];
+
+const NO_WINDOW = 0n;
+
+function activeDisplayArea(appWindow: AppWindow) {
+  const foreground = foregroundWindowHandle();
+  const hasForeground = foreground !== NO_WINDOW;
+  const windowId = hasForeground ? { value: foreground } : appWindow.id;
+  return DisplayArea.getFromWindowId(windowId, DisplayAreaFallback.Nearest);
+}
+
+const DISPLAY_FINDERS = {
+  [DockDisplay.active]: activeDisplayArea,
+  [DockDisplay.current]: appWindow => DisplayArea.getFromWindowId(appWindow.id, DisplayAreaFallback.Nearest),
+  [DockDisplay.primary]: () => DisplayArea.primary
+} as const satisfies Record<DockDisplay, (appWindow: AppWindow) => DisplayArea>;
+
+/**
+ * The display area `display` names for `appWindow`. The `active` one is the
+ * display of the foreground window, so an overlay that shows up while the user
+ * works on a second monitor lands there.
+ *
+ * @param options - The window and which display to find.
+ * @returns The WinUI `DisplayArea`: `workArea` is its desktop minus the taskbar, in device pixels.
+ */
+export function displayAreaOf({ appWindow, display }: {
+  appWindow: AppWindow;
+  display: DockDisplay;
+}) {
+  return DISPLAY_FINDERS[display](appWindow);
+}
+
+/** Where `dockWindow` puts a window. */
+export interface DockOptions {
+  /** The corner of the work area the window sits against. */
+  anchor: WindowAnchor;
+
+  /** Device pixels between the window and the two edges at that corner; 0 by default. */
+  inset?: number;
+
+  /** The display to dock to; the active one by default. */
+  display?: DockDisplay;
+}
+
+/**
+ * Moves the window against the `anchor` corner of a display's work area (the
+ * display minus the taskbar), `inset` device pixels in from both edges, with
+ * one `AppWindow.MoveAndResize`. The window keeps its size.
+ *
+ * A window moved to a display with another scale first goes there at its old
+ * size and is docked once Windows has rescaled it, so the corner it ends on is
+ * the one asked for at the size it really has.
+ *
+ * @param options - The window, the corner, the inset in device pixels (0 by
+ * default) and the display (the active one by default).
+ */
+export function dockWindow({ appWindow, anchor, inset = 0, display = DockDisplay.active }: DockOptions & {
+  appWindow: AppWindow;
+}) {
+  const area = displayAreaOf({
+    appWindow,
+    display
+  });
+  const { workArea } = area;
+  const currentArea = DisplayArea.getFromWindowId(appWindow.id, DisplayAreaFallback.Nearest);
+  const isOnOtherDisplay = currentArea.displayId.value !== area.displayId.value;
+  if (isOnOtherDisplay) {
+    appWindow.move({
+      x: workArea.x,
+      y: workArea.y
+    });
+  }
+
+  appWindow.moveAndResize(
+    dockedBounds({
+      area: workArea,
+      size: appWindow.size,
+      anchor,
+      inset
+    })
+  );
+}

package/src/window/index.ts

@@ -2,8 +2,12 @@ export type { RunWindowOptions } from "./application.ts";
 export { exitApplication, runWindow } from "./application.ts";
 export type { AppWindow, WindowOptions } from "./create-window.ts";
 export { Backdrop } from "./backdrop.ts";
+export type { WindowBounds, WindowSize } from "./anchor.ts";
+export { SizeToContent, WindowAnchor } from "./anchor.ts";
+export type { DockOptions } from "./dock.ts";
+export { displayAreaOf, DockDisplay, dockWindow } from "./dock.ts";
 export type { CaptionButtonColors, WindowRegion } from "./chrome.ts";
-export { TitleBarHeight, WindowPresentation, WindowTheme } from "./chrome.ts";
+export { IconShowOptions, TitleBarHeight, WindowPresentation, WindowTheme } from "./chrome.ts";
 export { createWindow } from "./create-window.ts";
 export type { HostEndOptions, HostLink } from "./host-link.ts";
 export { exitWhenHostEnds } from "./host-link.ts";