@ufoui/core 0.0.5 → 0.0.40

package/utils/color.d.ts

@@ -1,251 +1,105 @@
-import { ThemeExtendedColorKeys, ThemeSchemeKeys, ThemeSemanticColorKeys, ThemeSurfaceColorKeys } from '../types';
 /**
- * Represents a high-level semantic color token (e.g. `primary`, `error`, `success`).
- * Derived from {@link ThemeSemanticColorKeys}.
+ * Built-in semantic color names available in every theme.
+ *
  * @category Color
  */
-export type SemanticColor = (typeof ThemeSemanticColorKeys)[number];
+export type CoreSemanticColor = 'primary' | 'secondary' | 'tertiary' | 'warning' | 'info' | 'success' | 'error';
 /**
- * Represents tokens extending the {@link SemanticColor} set
- * with additional container and fixed variants.
- * Derived from {@link ThemeExtendedColorKeys}.
+ * Built-in surface color names intended for backgrounds, layers, and outlines.
+ *
  * @category Color
  */
-export type ExtendedColor = (typeof ThemeExtendedColorKeys)[number];
+export type CoreSurfaceColor = 'surface' | 'surfaceVariant' | 'background' | 'inverseSurface' | 'outline' | 'outlineVariant' | 'surfaceContainerLowest' | 'surfaceContainerLow' | 'surfaceContainer' | 'surfaceContainerHigh' | 'surfaceContainerHighest' | 'surfaceBright' | 'surfaceDim';
 /**
- * Represents surface-related color tokens extending {@link ExtendedColor},
- * including background, outline, and container surface roles.
- * Derived from {@link ThemeSurfaceColorKeys}.
+ * Built-in technical color names not intended for direct usage.
+ *
  * @category Color
  */
-export type SurfaceColor = (typeof ThemeSurfaceColorKeys)[number];
+export type CoreThemeColor = 'onSurface' | 'onSurfaceVariant' | 'onBackground' | 'inverseOnSurface' | 'inversePrimary' | 'surfaceTint' | 'scrim' | 'shadow' | 'black' | 'white';
+/** * Empty custom-color map used as the default generic parameter. * * @category Color */
+export type EmptyColors = Record<never, never>;
 /**
- * Represents any valid color token defined in the theme,
- * including semantic, extended, and surface roles.
- * Derived from {@link ThemeSchemeKeys}.
+ * Augmentation point for custom semantic colors.
+ *
+ * @example
+ * declare module '@ufoui/core' {
+ *   interface CustomColors {
+ *     myBlue: true;
+ *   }
+ * }
+ *
  * @category Color
  */
-export type ThemeColor = (typeof ThemeSchemeKeys)[number];
+export interface CustomColors {
+}
 /**
- * Generates utility class names (`uui-*`) for a given **semantic color** and its variants.
- *
- * @remarks
- * Produces `text`, `border`, and `background` class names for a semantic color and its
- * derived tokens (`on`, `container`, `fixed`, `fixedDim`, etc.).
- * If the provided key is invalid, `'primary'` is used as fallback.
+ * Base semantic color (core + augmented).
  *
- * All class names follow the pattern `uui-{type}-{kebab-case-color}`.
- *
- * @param color - Semantic color name (e.g. `'primary'`, `'error'`, `'success'`).
- * @returns Object with `uui-text-*`, `uui-border-*`, and `uui-bg-*` class names for all variants.
- *
- * @example
- * ```ts
- * getSemanticColorClasses('primary');
- * // → { textColor: 'uui-text-primary', bgOnColor: 'uui-bg-on-primary', ... }
- * ```
  * @category Color
  */
-export declare const getSemanticColorClasses: (color: SemanticColor) => {
-    textColor: string;
-    borderColor: string;
-    bgColor: string;
-    textOnColor: string;
-    borderOnColor: string;
-    bgOnColor: string;
-    textContainer: string;
-    borderContainer: string;
-    bgContainer: string;
-    textOnContainer: string;
-    borderOnContainer: string;
-    bgOnContainer: string;
-    textFixed: string;
-    borderFixed: string;
-    bgFixed: string;
-    textOnFixed: string;
-    borderOnFixed: string;
-    bgOnFixed: string;
-    textFixedDim: string;
-    borderFixedDim: string;
-    bgFixedDim: string;
-    textOnFixedVariant: string;
-    borderOnFixedVariant: string;
-    bgOnFixedVariant: string;
-};
+export type SemanticBaseColor = CoreSemanticColor | keyof CustomColors;
 /**
- * Bidirectional mapping between theme colors and their “on” counterparts.
- *
- * @remarks
- * Provides both directions — e.g. `'surface' → 'onSurface'` and `'onSurface' → 'surface'` —
- * for all semantic, extended, and surface tokens defined in {@link ThemeColor}.
- * Enables consistent inverse lookups for text/background pairings.
- *
- * Commonly used by {@link getSurfaceColorClasses}.
+ * Builds `on*` color name.
  *
  * @category Color
  */
-export declare const inverseColorMap: {
-    readonly surface: "onSurface";
-    readonly surfaceVariant: "onSurfaceVariant";
-    readonly surfaceContainerLowest: "onSurface";
-    readonly surfaceContainerLow: "onSurface";
-    readonly surfaceContainer: "onSurface";
-    readonly surfaceContainerHigh: "onSurface";
-    readonly surfaceContainerHighest: "onSurface";
-    readonly surfaceDim: "onSurface";
-    readonly surfaceBright: "onSurface";
-    readonly background: "onBackground";
-    readonly inverseSurface: "inverseOnSurface";
-    readonly primary: "onPrimary";
-    readonly secondary: "onSecondary";
-    readonly tertiary: "onTertiary";
-    readonly warning: "onWarning";
-    readonly info: "onInfo";
-    readonly success: "onSuccess";
-    readonly error: "onError";
-    readonly primaryContainer: "onPrimaryContainer";
-    readonly primaryFixed: "onPrimaryFixed";
-    readonly primaryFixedDim: "onPrimaryFixedVariant";
-    readonly secondaryContainer: "onSecondaryContainer";
-    readonly secondaryFixed: "onSecondaryFixed";
-    readonly secondaryFixedDim: "onSecondaryFixedVariant";
-    readonly tertiaryContainer: "onTertiaryContainer";
-    readonly tertiaryFixed: "onTertiaryFixed";
-    readonly tertiaryFixedDim: "onTertiaryFixedVariant";
-    readonly warningContainer: "onWarningContainer";
-    readonly warningFixed: "onWarningFixed";
-    readonly warningFixedDim: "onWarningFixedVariant";
-    readonly infoContainer: "onInfoContainer";
-    readonly infoFixed: "onInfoFixed";
-    readonly infoFixedDim: "onInfoFixedVariant";
-    readonly successContainer: "onSuccessContainer";
-    readonly successFixed: "onSuccessFixed";
-    readonly successFixedDim: "onSuccessFixedVariant";
-    readonly errorContainer: "onErrorContainer";
-    readonly errorFixed: "onErrorFixed";
-    readonly errorFixedDim: "onErrorFixedVariant";
-    readonly outline: "surface";
-    readonly outlineVariant: "inverseSurface";
-    readonly inversePrimary: "onPrimaryContainer";
-    readonly black: "white";
-    readonly white: "black";
-    readonly onSurface: "surface";
-    readonly onSurfaceVariant: "surfaceVariant";
-    readonly onBackground: "background";
-    readonly inverseOnSurface: "inverseSurface";
-    readonly onPrimary: "primary";
-    readonly onSecondary: "secondary";
-    readonly onTertiary: "tertiary";
-    readonly onWarning: "warning";
-    readonly onInfo: "info";
-    readonly onSuccess: "success";
-    readonly onError: "error";
-    readonly onPrimaryContainer: "primaryContainer";
-    readonly onSecondaryContainer: "secondaryContainer";
-    readonly onTertiaryContainer: "tertiaryContainer";
-    readonly onWarningContainer: "warningContainer";
-    readonly onInfoContainer: "infoContainer";
-    readonly onSuccessContainer: "successContainer";
-    readonly onErrorContainer: "errorContainer";
-};
+export type OnColor<T extends string> = `on${Capitalize<T>}`;
 /**
- * Returns utility class names (`uui-*`) for a given surface color and its mapped “on” color.
+ * Semantic color used in component APIs.
  *
- * @remarks
- * Uses the {@link inverseColorMap} to find the related “on” color
- * (e.g. `'surfaceContainer'` → `'onSurface'`).
- * Produces `text`, `border`, and `background` variants for both.
- * All names are kebab-cased (e.g. `'surfaceContainerHigh'` → `'surface-container-high'`).
- *
- * @param color - Surface color key (e.g. `'surfaceContainerHigh'`).
- * @returns Object with `uui-text-*`, `uui-border-*`, and `uui-bg-*` class names for base and on-color.
- *
- * @example
- * ```ts
- * getSurfaceColorClasses('surfaceContainer');
- * // → { textColor: 'uui-text-surface-container', textOnColor: 'uui-text-on-surface', ... }
- * ```
  * @category Color
  */
-export declare const getSurfaceColorClasses: (color: SurfaceColor) => {
-    readonly textColor: `uui-text-${string}`;
-    readonly textOnColor: `uui-text-${string}`;
-    readonly borderColor: `uui-border-${string}`;
-    readonly borderOnColor: `uui-border-${string}`;
-    readonly bgColor: `uui-bg-${string}`;
-    readonly bgOnColor: `uui-bg-${string}`;
-};
+export type SemanticColor = SemanticBaseColor;
 /**
- * Returns utility class names (`uui-*`) for any theme color token.
+ * Extended semantic colors.
  *
- * @remarks
- * Generates `text`, `border`, and `background` class names based on the provided
- * {@link ThemeColor}. If the color key is invalid, `'primary'` is used as fallback.
- *
- * @param color - Theme color token (e.g. `'primary'`, `'surfaceContainerHigh'`, `'error'`).
- * @returns An object with `uui-text-*`, `uui-border-*`, and `uui-bg-*` class names.
- *
- * @example
- * ```ts
- * getColorClasses('error');
- * // → { textColor: 'uui-text-error', borderColor: 'uui-border-error', bgColor: 'uui-bg-error' }
- * ```
  * @category Color
  */
-export declare const getColorClasses: (color: ThemeColor) => {
-    readonly textColor: `uui-text-${string}`;
-    readonly borderColor: `uui-border-${string}`;
-    readonly bgColor: `uui-bg-${string}`;
-};
+export type ExtendedColor = `${SemanticBaseColor}Container` | `${SemanticBaseColor}Fixed` | `${SemanticBaseColor}FixedDim`;
 /**
- * Represents the available border color options.
+ * `on*` counterparts for extended colors.
  *
  * @category Color
  */
-export type BorderColor = SurfaceColor;
+export type OnExtendedColor = OnColor<`${SemanticBaseColor}Container`> | OnColor<`${SemanticBaseColor}Fixed`> | OnColor<`${SemanticBaseColor}FixedVariant`>;
 /**
- * Returns the appropriate border color class for a given configuration.
+ * Surface colors.
  *
- * @remarks
- * Typical border colors are `'outline'` and `'outlineVariant'`, matching MD3 tokens.
- * @param borderColor - Border color keyword or surface color token.
- * @returns The resolved border color class (e.g. `'uui-border-surface-container-high'`).
- *
- * @example
- * ```ts
- * getBorderColorClass('surfaceContainer'); // → 'uui-border-surface-container'
- * ```
  * @category Color
  */
-export declare function getBorderColorClass(borderColor: BorderColor): `uui-border-${string}`;
+export type SurfaceColor = CoreSurfaceColor | ExtendedColor;
 /**
- * Returns all CSS variable references for a **semantic color**.
+ * Colors allowed in component props.
  *
- * @remarks
- * Generates `var(--uui-color-*)` tokens only for semantic colors
- * defined in {@link SemanticColor} (e.g. `primary`, `error`, `success`).
- * Useful for dynamic component theming and inline styles.
+ * @category Color
+ */
+export type BaseColor = SemanticColor | SurfaceColor;
+/**
+ * Full theme color set.
  *
- * @param color - Semantic color key (e.g. `'primary'`, `'error'`, `'info'`).
- * @returns Object containing `var(--uui-color-...)` references for all variants.
+ * @category Color
+ */
+export type ThemeColor = BaseColor | OnColor<SemanticBaseColor> | OnExtendedColor | CoreThemeColor;
+/**
+ * Border color.
  *
- * @example
- * ```ts
- * const vars = getSemanticColorVar('primary');
- * // → "var(--uui-color-primary)", "var(--uui-color-on-primary)"
- * ```
  * @category Color
  */
-export declare const getSemanticColorVar: (color: SemanticColor) => {
-    color: string;
-    onColor: string;
-    container: string;
-    onContainer: string;
-    fixed: string;
-    fixedDim: string;
-    onFixed: string;
-    onFixedVariant: string;
-};
+export type BorderColor = BaseColor;
+export declare function getOnColorName(colorName: ThemeColor): ThemeColor | undefined;
+/**
+ * Returns all color names from the global registry for the selected type.
+ *
+ * @param type - Color type to filter by.
+ * @returns List of color names matching the requested type.
+ * @category Theme
+ */
+export declare function getColorNames(type: 'semantic'): SemanticColor[];
+export declare function getColorNames(type: 'extended'): ExtendedColor[];
+export declare function getColorNames(type: 'surface'): SurfaceColor[];
+export declare function getColorNames(type: 'theme'): ThemeColor[];
+export declare function getColorNames(type: 'base'): BaseColor[];
+export declare function getColorNames(type: 'border'): BorderColor[];
 /**
  * Returns basic CSS variable references for a **surface color**.
  *
@@ -264,7 +118,7 @@ export declare const getSemanticColorVar: (color: SemanticColor) => {
  * ```
  * @category Color
  */
-export declare const getSurfaceColorVar: (color: SurfaceColor) => {
+export declare const getSurfaceColorVar: (color: BaseColor) => {
     color: string;
     onColor: string;
 };
@@ -312,14 +166,5 @@ export declare const hexToRgb: (colorValue: string) => string;
  * @category Color
  */
 export declare function getTintOverlayColor(elevation: number, tintColor: string): string;
-/**
- * Returns a set of predefined utility class names for fixed theme colors.
- *
- * Each entry maps text, border, outline, and background variants like:
- * `textSurface`, `bgOnSurface`, `borderOutlineVariant`, etc.
- *
- * @returns Object with fixed color class mappings.
- */
-export declare const getFixedColorClasses: () => Record<string, string>;
 export declare function capitalize(s: string): string;
 export declare function getBorderColor(borderColor?: BorderColor): BorderColor;

package/utils/colorRegistry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Runtime color type used by the generated color registry.
+ *
+ * @category Theme
+ */
+export type ColorType = 'semantic' | 'surface' | 'extended' | 'base' | 'border' | 'theme';
+/**
+ * Metadata entry describing how a color name should be used.
+ *
+ * @category Theme
+ */
+export interface ColorRegistryEntry {
+    /** Usage type assigned to the color name. */
+    type: ColorType;
+    /** Paired contrast color name (e.g. `primary` -> `onPrimary`). */
+    onColor?: string;
+}
+/**
+ * Global color registry keyed by theme color names.
+ *
+ * @category Theme
+ */
+export type ColorRegistry = Record<string, ColorRegistryEntry | undefined>;
+/**
+ * Replaces the global color registry.
+ *
+ * @param registry - New registry produced by theme generation.
+ * @category Theme
+ */
+export declare function setColorRegistry(registry: ColorRegistry): void;
+/**
+ * Returns the current global color registry.
+ *
+ * @returns The last registry set by theme generation.
+ * @category Theme
+ */
+export declare function getColorRegistry(): ColorRegistry;
+/**
+ * Resolves the paired contrast color from the global color registry.
+ *
+ * @param colorName - Base color name from the registry.
+ * @returns Linked `onColor` value if present.
+ * @category Theme
+ */

package/utils/controlStyle.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { SemanticColor, SurfaceColor, ThemeColor } from './color';
+import { BaseColor, SemanticColor, ThemeColor } from './color';
 /**
  * Creates a strictly typed style builder for MD3 color tokens.
  *
@@ -9,49 +9,49 @@ type CSSPropertyKey = Extract<keyof React.CSSProperties, string>;
 type CSSVar = `--${string}`;
 export declare function ControlStyle(initial?: React.CSSProperties): {
     bg: ((color?: ThemeColor) => void) & {
-        on(color?: SurfaceColor): void;
+        on(color?: BaseColor): void;
         container(color?: SemanticColor): void;
         onContainer(color?: SemanticColor): void;
         fixed(color?: SemanticColor): void;
         fixedDim(color?: SemanticColor): void;
     };
     text: ((color?: ThemeColor) => void) & {
-        on(color?: SurfaceColor): void;
+        on(color?: BaseColor): void;
         container(color?: SemanticColor): void;
         onContainer(color?: SemanticColor): void;
         fixed(color?: SemanticColor): void;
         fixedDim(color?: SemanticColor): void;
     };
     border: ((color?: ThemeColor) => void) & {
-        on(color?: SurfaceColor): void;
+        on(color?: BaseColor): void;
         container(color?: SemanticColor): void;
         onContainer(color?: SemanticColor): void;
         fixed(color?: SemanticColor): void;
         fixedDim(color?: SemanticColor): void;
     };
     outline: ((color?: ThemeColor) => void) & {
-        on(color?: SurfaceColor): void;
+        on(color?: BaseColor): void;
         container(color?: SemanticColor): void;
         onContainer(color?: SemanticColor): void;
         fixed(color?: SemanticColor): void;
         fixedDim(color?: SemanticColor): void;
     };
     current: ((color?: ThemeColor) => void) & {
-        on(color?: SurfaceColor): void;
+        on(color?: BaseColor): void;
         container(color?: SemanticColor): void;
         onContainer(color?: SemanticColor): void;
         fixed(color?: SemanticColor): void;
         fixedDim(color?: SemanticColor): void;
     };
     stroke: ((color?: ThemeColor) => void) & {
-        on(color?: SurfaceColor): void;
+        on(color?: BaseColor): void;
         container(color?: SemanticColor): void;
         onContainer(color?: SemanticColor): void;
         fixed(color?: SemanticColor): void;
         fixedDim(color?: SemanticColor): void;
     };
     fill: ((color?: ThemeColor) => void) & {
-        on(color?: SurfaceColor): void;
+        on(color?: BaseColor): void;
         container(color?: SemanticColor): void;
         onContainer(color?: SemanticColor): void;
         fixed(color?: SemanticColor): void;

package/utils/flatChildren.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+/**
+ * Flattens a React node tree by one level, unwrapping Fragments.
+ *
+ * Accepts a single element, a Fragment, or an array and returns a flat array
+ * of `ReactNode` items. Useful in components that need to identify or count
+ * specific child types via type guards.
+ *
+ * @param node - React node to flatten.
+ * @returns Flat array of React nodes with top-level Fragments unwrapped.
+ *
+ * @example
+ * const items = flatChildren(actions).filter(isDialogAction);
+ *
+ * @category Utils
+ */
+export declare const flatChildren: (node: ReactNode) => ReactNode[];

package/utils/generateMaterialColors.d.ts

@@ -1,5 +1,5 @@
 import { PartialThemeSchemes, ThemeSchemes } from '../types';
-export type ExtraColorOverrides = Partial<Record<'info' | 'warning' | 'success', string>>;
+export type UserColors = Record<string, string>;
 /**
  * Generates a full ThemeSchemes object (light and dark modes) based on a seed color,
  * optional token overrides, and custom semantic colors (info, warning, success).
@@ -12,20 +12,20 @@ export type ExtraColorOverrides = Partial<Record<'info' | 'warning' | 'success',
  *
  * @param seedColor - Optional seed color in hex (e.g. "#6200ee"). Used as the base for the primary palette.
  *                    Defaults to `#6750A4` if not provided.
- * @param customSchemes - Optional overrides for light and dark color values.
- *                        Partial values will be merged with generated ones.
- * @param extraColors - Optional custom base colors for `info`, `warning`, and `success`.
- *                      These will override the default values (`#03a9f4`, `#ffd600`, `#689f38`).
+ * @param colors - Optional map of custom base colors. Defaults include `info`, `warning`, and `success`.
+ *                 Any key can be provided (e.g. `brand`, `neutralStrong`, `secondary`).
+ * @param customSchemes - Optional skin overrides for schemes (e.g. light/dark/high-contrast).
+ *                        Applied as the final merge step.
  *
  * @returns A fully resolved ThemeSchemes object with all required color roles populated for light and dark modes.
+ *          Also updates the global color registry via `setColorRegistry()`.
  *
  * @example
  * ```ts
  * const schemes = generateMaterialColors('#6200ee', { info: '#2196f3' }, {});
  * const primary = schemes.light.primary;
- * const infoContainer = schemes.dark.infoContainer;
  * ```
  *
  * @category Theme
  */
-export declare function generateMaterialColors(seedColor?: string, extraColors?: ExtraColorOverrides, customSchemes?: PartialThemeSchemes): ThemeSchemes;
+export declare function generateMaterialColors(seedColor?: string, colors?: UserColors, customSchemes?: PartialThemeSchemes): ThemeSchemes;

package/utils/getWrapperStyle.d.ts

@@ -0,0 +1,53 @@
+import { CSSProperties } from 'react';
+/**
+ * Props for wrapper-level behavior.
+ *
+ * Applies outer layout such as margin, positioning and stacking.
+ * Does not affect internal layout or content.
+ *
+ * @category Utils
+ */
+export type WrapperProps = {
+    /** Margin on all sides. */
+    m?: number | string;
+    /** Horizontal margin (left + right). */
+    mx?: number | string;
+    /** Vertical margin (top + bottom). */
+    my?: number | string;
+    /** Margin top. */
+    mt?: number | string;
+    /** Margin bottom. */
+    mb?: number | string;
+    /** Margin left. */
+    ml?: number | string;
+    /** Margin right. */
+    mr?: number | string;
+    /** Top offset. */
+    top?: number | string;
+    /** Right offset. */
+    right?: number | string;
+    /** Bottom offset. */
+    bottom?: number | string;
+    /** Left offset. */
+    left?: number | string;
+    /** Stacking order. */
+    zIndex?: number;
+    /** CSS position value. */
+    position?: CSSProperties['position'];
+};
+/**
+ * Resolves wrapper props into style and remaining props.
+ *
+ * Margin shorthands priority:
+ * mt/ml/... overrides mx/my, which overrides m.
+ *
+ * @function
+ * @param props Wrapper configuration.
+ * @returns Object containing wrapperStyle and otherProps.
+ *
+ * @category Utils
+ */
+export declare function getWrapperStyle(props: WrapperProps): {
+    wrapperStyle: CSSProperties;
+    otherProps: {};
+};

package/utils/index.d.ts

@@ -3,7 +3,11 @@ export * from './utils';
 export * from './calculateFloatingPosition';
 export * from './interactionMode';
 export * from './generateMaterialColors';
-export * from './generateSchemes';
+export * from './applyThemeTokens';
 export * from './toasts';
 export * from './uniqueID';
 export * from './controlStyle';
+export * from './getWrapperStyle';
+export * from './flatChildren';
+export * from './renderPortal';
+export * from './colorRegistry';

package/utils/renderPortal.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode, ReactPortal } from 'react';
+/**
+ * Returns the portal host element `#id`, creating it when missing.
+ *
+ * @remarks
+ * If the element is missing, a `div` with the given `id` is appended to `document.body`.
+ * The portal mounts **into** that host — `document.body` itself is never used as the
+ * direct portal container.
+ *
+ * @param rootId - `id` of the root node (e.g. `'dialog-root'`).
+ *
+ * @returns The host element, or `null` when `document` is unavailable (e.g. SSR).
+ *
+ * @category Utils
+ */
+export declare function ensurePortalRoot(rootId: string): HTMLElement | null;
+/**
+ * Renders children into a dedicated portal root, creating that node when absent.
+ *
+ * @remarks
+ * Uses {@link ensurePortalRoot}; returns `null` when the document is not available.
+ *
+ * @param rootId - `id` of the portal host (e.g. `'dialog-root'`).
+ * @param children - Tree to render into the host.
+ *
+ * @returns A {@link https://react.dev/reference/react-dom/createPortal | React portal}, or `null`.
+ *
+ * @category Utils
+ */
+export declare function renderPortal(rootId: string, children: ReactNode): ReactPortal | null;

package/utils/toasts/ensureViewport.d.ts

@@ -1,2 +1,7 @@
-export declare const TOAST_VIEWPORT_ID = "uui-toast-viewport-root";
+/**
+ * Ensures that a global toast viewport exists.
+ *
+ * If the user already rendered ToastViewport manually,
+ * no additional viewport is created.
+ */
 export declare function ensureViewport(): void;