@geektech/one 0.0.1 → 0.1.0

package/dist/message/MessageOverlay.d.ts

@@ -0,0 +1,25 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneFeedbackVariant } from '../overlay';
+import { type OneNamedStyle } from '../styles/shared';
+import type { OneMessageOptions, OneMessagePlacement } from './types';
+export interface MessageOverlayProps extends Omit<OneMessageOptions, 'container'> {
+    variant: OneFeedbackVariant;
+    duration: number;
+    placement: OneMessagePlacement;
+    requestClose(): void;
+}
+export declare const ONE_MESSAGE_STYLES: OneNamedStyle[];
+interface MessageOverlayState {
+}
+export declare class MessageOverlay extends Component<MessageOverlayProps, MessageOverlayState> {
+    private timer;
+    mount(container: HTMLElement): void;
+    protected initState(): MessageOverlayState;
+    protected initStyles(): void;
+    protected onMounted(): void;
+    protected onUnmounted(): void;
+    setProps(props: Partial<MessageOverlayProps>): void;
+    protected render(): VNode;
+    private decorateGroup;
+}
+export {};

package/dist/message/OneMessage.d.ts

@@ -0,0 +1,19 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneMessageProps } from './types';
+interface OneMessageState {
+    internalOpen: boolean;
+}
+export declare class OneMessage extends Component<OneMessageProps, OneMessageState> {
+    private controller;
+    private viewMounted;
+    protected initState(): OneMessageState;
+    protected initStyles(): void;
+    protected onMounted(): void;
+    protected beforeUpdate(): void;
+    protected beforeUnmount(): void;
+    protected render(): VNode;
+    private createOverlay;
+    private synchronizeOverlay;
+    private requestClose;
+}
+export {};

package/dist/message/index.d.ts

@@ -0,0 +1,6 @@
+export { MessageOverlay, ONE_MESSAGE_STYLES } from './MessageOverlay';
+export { OneMessage } from './OneMessage';
+export { OneMessageService, createOneMessageService, oneMessage, } from './service';
+export { OneMessageTimer } from './timer';
+export type { OneTimerScheduler } from './timer';
+export type { OneMessageOptions, OneMessagePlacement, OneMessageProps, } from './types';

package/dist/message/normalize.d.ts

@@ -0,0 +1,8 @@
+import type { OneFeedbackVariant } from '../overlay';
+import type { OneMessageOptions, OneMessagePlacement } from './types';
+export interface NormalizedOneMessageOptions extends Omit<OneMessageOptions, 'variant' | 'duration' | 'placement'> {
+    variant: OneFeedbackVariant;
+    duration: number;
+    placement: OneMessagePlacement;
+}
+export declare function normalizeOneMessageOptions(options: OneMessageOptions): NormalizedOneMessageOptions;

package/dist/message/service.d.ts

@@ -0,0 +1,17 @@
+import { type OneOverlayHandle, type OneOverlayHost } from '../overlay';
+import type { OneMessageOptions } from './types';
+type OneMessageShortcutOptions = Omit<OneMessageOptions, 'content' | 'variant'>;
+export declare class OneMessageService {
+    private readonly suppliedHost?;
+    constructor(suppliedHost?: OneOverlayHost | undefined);
+    open(options: OneMessageOptions): OneOverlayHandle<OneMessageOptions>;
+    info(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    success(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    warning(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    error(content: string, options?: OneMessageShortcutOptions): OneOverlayHandle<OneMessageOptions>;
+    close(id: string): void;
+    closeAll(): void;
+}
+export declare function createOneMessageService(host?: OneOverlayHost): OneMessageService;
+export declare const oneMessage: OneMessageService;
+export {};

package/dist/message/timer.d.ts

@@ -0,0 +1,21 @@
+export interface OneTimerScheduler {
+    now(): number;
+    set(callback: () => void, delay: number): unknown;
+    clear(handle: unknown): void;
+}
+export declare class OneMessageTimer {
+    private readonly scheduler;
+    private readonly onElapsed;
+    private handle;
+    private remaining;
+    private startedAt;
+    private paused;
+    private disposed;
+    constructor(duration: number, scheduler: OneTimerScheduler | undefined, onElapsed: () => void);
+    pause(): void;
+    resume(): void;
+    reset(duration: number): void;
+    dispose(): void;
+    private schedule;
+    private clear;
+}

package/dist/message/types.d.ts

@@ -0,0 +1,14 @@
+import type { OneFeedbackVariant, OneOverlayContainer } from '../overlay';
+export type OneMessagePlacement = 'top-start' | 'top' | 'top-end' | 'bottom-start' | 'bottom' | 'bottom-end';
+export interface OneMessageOptions {
+    content: string;
+    variant?: OneFeedbackVariant;
+    duration?: number;
+    closable?: boolean;
+    placement?: OneMessagePlacement;
+    container?: OneOverlayContainer;
+}
+export interface OneMessageProps extends OneMessageOptions {
+    open?: boolean;
+    defaultOpen?: boolean;
+}

package/dist/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export { normalizeNonNegativeInteger, normalizePositiveInteger, normalizePositiveIntegerList, } from './normalize';
+export type { OneNavigationChangeEvent } from './types';

package/dist/navigation/normalize.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeNonNegativeInteger(value: unknown, fallback: number): number;
+export declare function normalizePositiveInteger(value: unknown, fallback: number): number;
+export declare function normalizePositiveIntegerList(values: unknown, fallback: readonly number[]): number[];

package/dist/navigation/types.d.ts

@@ -0,0 +1,4 @@
+export interface OneNavigationChangeEvent<TValue> {
+    value: TValue;
+    originalEvent: Event;
+}

package/dist/overlay/container.d.ts

@@ -0,0 +1,2 @@
+import type { OneOverlayContainer } from './types';
+export declare function resolveOneOverlayContainer(container?: OneOverlayContainer, targetDocument?: Document | null): HTMLElement;

package/dist/overlay/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class OneOverlayEnvironmentError extends Error {
+    constructor(message?: string);
+}
+export declare class OneOverlayContainerError extends Error {
+    constructor(message: string);
+}
+export declare class OneTooltipTriggerError extends Error {
+    constructor(message?: string);
+}

package/dist/overlay/host.d.ts

@@ -0,0 +1,16 @@
+import type { OneOverlayHandle, OneOverlayHost, OneOverlayKind, OneOverlayOpenRequest } from './types';
+export declare class DomOneOverlayHost implements OneOverlayHost {
+    private readonly targetDocument;
+    private readonly entries;
+    private readonly records;
+    private sequence;
+    constructor(targetDocument: Document);
+    open<TOptions extends object>(request: OneOverlayOpenRequest<TOptions>): OneOverlayHandle<TOptions>;
+    close(id: string): void;
+    closeAll(kind?: OneOverlayKind): void;
+    isTop(id: string): boolean;
+    private getOrCreateEntry;
+    private getOrCreateGroup;
+    private removeRecord;
+}
+export declare function getDefaultOneOverlayHost(targetDocument?: Document): OneOverlayHost;

package/dist/overlay/index.d.ts

@@ -0,0 +1,7 @@
+export { resolveOneOverlayContainer } from './container';
+export { OneOverlayContainerError, OneOverlayEnvironmentError, OneTooltipTriggerError, } from './errors';
+export { DomOneOverlayHost, getDefaultOneOverlayHost } from './host';
+export { OneOverlayMountController } from './mount-controller';
+export { OneFloatingPositioner } from './positioner';
+export type { OneOverlayPositionRequest, OneOverlayPositionResult, OneOverlayPositioner, OneOverlayRect, } from './positioner';
+export type { OneFeedbackVariant, OneManagedOverlay, OneOverlayContainer, OneOverlayFactory, OneOverlayFactoryContext, OneOverlayHandle, OneOverlayHost, OneOverlayKind, OneOverlayOpenRequest, OneOverlayPlacement, } from './types';

package/dist/overlay/mount-controller.d.ts

@@ -0,0 +1,13 @@
+import type { OneOverlayContainer, OneOverlayFactory, OneOverlayHost, OneOverlayKind } from './types';
+export declare class OneOverlayMountController<TOptions extends object> {
+    private readonly host;
+    private readonly kind;
+    private readonly factory;
+    private readonly group?;
+    private handle;
+    constructor(host: OneOverlayHost, kind: OneOverlayKind, factory: OneOverlayFactory<TOptions>, group?: string | undefined);
+    open(container?: OneOverlayContainer): void;
+    update(options: Partial<TOptions>): void;
+    close(): void;
+    isOpen(): boolean;
+}

package/dist/overlay/positioner.d.ts

@@ -0,0 +1,36 @@
+import type { OneOverlayPlacement } from './types';
+export interface OneOverlayRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface OneOverlayPositionRequest {
+    reference: OneOverlayRect;
+    floating: OneOverlayRect;
+    boundary: OneOverlayRect;
+    placement: OneOverlayPlacement;
+    offset: number;
+    padding: number;
+}
+export interface OneOverlayPositionResult {
+    x: number;
+    y: number;
+    placement: OneOverlayPlacement;
+    arrow: {
+        x?: number;
+        y?: number;
+    };
+}
+export interface OneOverlayPositioner {
+    compute(request: OneOverlayPositionRequest): OneOverlayPositionResult;
+    autoUpdate(reference: HTMLElement, floating: HTMLElement, update: () => void): () => void;
+}
+export declare class OneFloatingPositioner implements OneOverlayPositioner {
+    compute(request: OneOverlayPositionRequest): OneOverlayPositionResult;
+    autoUpdate(reference: HTMLElement, floating: HTMLElement, update: () => void): () => void;
+}

package/dist/overlay/types.d.ts

@@ -0,0 +1,32 @@
+export type OneFeedbackVariant = 'info' | 'success' | 'warning' | 'error';
+export type OneOverlayContainer = HTMLElement | (() => HTMLElement | null);
+export type OneOverlayPlacement = 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end';
+export type OneOverlayKind = 'message' | 'dialog' | 'tooltip';
+export interface OneOverlayHandle<TOptions extends object> {
+    readonly id: string;
+    update(options: Partial<TOptions>): void;
+    close(): void;
+}
+export interface OneManagedOverlay<TOptions extends object> {
+    update(options: Partial<TOptions>): void;
+    destroy(): void;
+}
+export interface OneOverlayFactoryContext {
+    id: string;
+    slot: HTMLElement;
+    requestClose(): void;
+    isTop(): boolean;
+}
+export type OneOverlayFactory<TOptions extends object> = (context: OneOverlayFactoryContext) => OneManagedOverlay<TOptions>;
+export interface OneOverlayOpenRequest<TOptions extends object> {
+    kind: OneOverlayKind;
+    group?: string;
+    container?: OneOverlayContainer;
+    factory: OneOverlayFactory<TOptions>;
+}
+export interface OneOverlayHost {
+    open<TOptions extends object>(request: OneOverlayOpenRequest<TOptions>): OneOverlayHandle<TOptions>;
+    close(id: string): void;
+    closeAll(kind?: OneOverlayKind): void;
+    isTop(id: string): boolean;
+}

package/dist/pagination/OnePagination.d.ts

@@ -0,0 +1,42 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OnePaginationChangeEvent {
+    page: number;
+    pageSize: number;
+    originalEvent: Event;
+}
+export interface OnePaginationProps {
+    total: number;
+    page?: number;
+    defaultPage?: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: readonly number[];
+    siblingCount?: number;
+    showQuickJumper?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+interface OnePaginationState {
+    internalPage: number;
+    internalPageSize: number;
+    jumpValue: string;
+}
+export declare const ONE_PAGINATION_STYLES: OneNamedStyle[];
+export declare class OnePagination extends Component<OnePaginationProps, OnePaginationState> {
+    protected initState(): OnePaginationState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private effectivePageSize;
+    private pageCount;
+    private effectivePage;
+    private sizeOptions;
+    private renderPageButton;
+    private renderEllipsis;
+    private handleSizeChange;
+    private handleJumpInput;
+    private handleJumpKeydown;
+    private requestChange;
+    private submitJump;
+}
+export {};

package/dist/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { ONE_PAGINATION_STYLES, OnePagination, type OnePaginationChangeEvent, type OnePaginationProps, } from './OnePagination';
+export { createOnePaginationTokens, type OnePaginationToken } from './tokens';

package/dist/pagination/tokens.d.ts

@@ -0,0 +1,2 @@
+export type OnePaginationToken = number | 'ellipsis-start' | 'ellipsis-end';
+export declare function createOnePaginationTokens(pageCount: number, page: number, siblingCount: number): OnePaginationToken[];

package/dist/styles/shared.d.ts

@@ -9,6 +9,10 @@ export declare const ONE_THEME_DEFAULTS: {
     readonly colorPrimaryHover: "#4bc944";
     readonly colorDanger: "#b83232";
     readonly colorDangerHover: "#9f2d2d";
+    readonly colorInfo: "#2563eb";
+    readonly colorSuccess: "#2f7c39";
+    readonly colorWarning: "#9a6700";
+    readonly colorOverlay: "rgba(22, 32, 24, 0.48)";
     readonly colorSurface: "#ffffff";
     readonly colorText: "#162018";
     readonly colorMuted: "#647268";
@@ -24,7 +28,16 @@ export declare const ONE_THEME_DEFAULTS: {
     readonly fontSizeMd: "14px";
     readonly fontSizeLg: "16px";
     readonly shadowCard: "0 12px 30px rgba(32, 74, 38, 0.1)";
+    readonly shadowOverlay: "0 18px 48px rgba(22, 32, 24, 0.2)";
+    readonly zIndexDialog: "1000";
+    readonly zIndexMessage: "1100";
+    readonly zIndexTooltip: "1200";
     readonly fontFamily: "Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
 };
+export declare const ONE_THEME_TYPOGRAPHY_PROPERTIES: Readonly<{
+    fontFamily: "var(--one-font-family, Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif)";
+    lineHeight: "var(--one-line-height, 1.5)";
+}>;
+export declare function oneThemeBorder(color?: string): string;
 export declare function normalizeOneSize(value: unknown): OneComponentSize;
 export declare function oneStylesToSheet(styles: readonly OneNamedStyle[]): StyleSheet;

package/dist/tabs/OneTabs.d.ts

@@ -0,0 +1,34 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneNavigationChangeEvent } from '../navigation';
+import { type OneNamedStyle } from '../styles/shared';
+export interface OneTabItem {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export type OneTabsChangeEvent = OneNavigationChangeEvent<string>;
+export interface OneTabsProps {
+    items: readonly OneTabItem[];
+    value?: string;
+    defaultValue?: string;
+    id?: string;
+    ariaLabel?: string;
+    children?: Array<VNode | string>;
+}
+interface OneTabsState {
+    internalValue: string | undefined;
+}
+export declare const ONE_TABS_STYLES: OneNamedStyle[];
+export declare class OneTabs extends Component<OneTabsProps, OneTabsState> {
+    private readonly idPrefix;
+    protected initState(): OneTabsState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private normalizedItems;
+    private effectiveValue;
+    private activate;
+    private handleKeydown;
+    private enabledIndices;
+    private focusTab;
+}
+export {};

package/dist/tabs/index.d.ts

@@ -0,0 +1,2 @@
+export { ONE_TABS_STYLES, OneTabs } from './OneTabs';
+export type { OneTabItem, OneTabsChangeEvent, OneTabsProps } from './OneTabs';

package/dist/tag/OneTag.d.ts

@@ -0,0 +1,21 @@
+import { Component, type VNode } from '@geektech/tsone';
+import { type OneDataDisplayVariant } from '../data-display';
+import { type OneNamedStyle } from '../styles/shared';
+import type { OneComponentSize } from '../types';
+export interface OneTagProps {
+    variant?: OneDataDisplayVariant;
+    size?: OneComponentSize;
+    closable?: boolean;
+    children?: Array<VNode | string>;
+}
+interface OneTagState {
+    visible: boolean;
+}
+export declare const ONE_TAG_STYLES: OneNamedStyle[];
+export declare class OneTag extends Component<OneTagProps, OneTagState> {
+    protected initState(): OneTagState;
+    protected initStyles(): void;
+    protected render(): VNode;
+    private close;
+}
+export {};

package/dist/tag/index.d.ts

@@ -0,0 +1,2 @@
+export { OneTag } from './OneTag';
+export type { OneTagProps } from './OneTag';

package/dist/theme/OneThemeService.d.ts

@@ -0,0 +1,14 @@
+import type { OneThemeInitOptions, OneThemeService } from './types';
+type OneThemeRootResolver = () => HTMLElement | undefined;
+export declare class DomOneThemeService implements OneThemeService {
+    private readonly resolveRoot;
+    private themes;
+    private activeTheme;
+    constructor(resolveRoot: OneThemeRootResolver);
+    get currentTheme(): string;
+    init(options?: OneThemeInitOptions): void;
+    switch(name: string): void;
+    private requireRoot;
+}
+export declare const oneTheme: OneThemeService;
+export {};

package/dist/theme/default-theme.d.ts

@@ -0,0 +1,2 @@
+import type { OneResolvedTheme } from './types';
+export declare const ONE_DEFAULT_THEME: OneResolvedTheme;

package/dist/theme/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class OneThemeConfigError extends Error {
+    constructor(message: string);
+}
+export declare class OneThemeNotFoundError extends Error {
+    constructor(themeName: string);
+}
+export declare class OneThemeEnvironmentError extends Error {
+    constructor();
+}

package/dist/theme/index.d.ts

@@ -0,0 +1,4 @@
+export { ONE_DEFAULT_THEME } from './default-theme';
+export { OneThemeConfigError, OneThemeEnvironmentError, OneThemeNotFoundError, } from './errors';
+export { oneTheme } from './OneThemeService';
+export type { OneResolvedTheme, OneThemeBorder, OneThemeColors, OneThemeDefinition, OneThemeInitOptions, OneThemeRadius, OneThemeService, OneThemeTypography, } from './types';

package/dist/theme/normalize.d.ts

@@ -0,0 +1,6 @@
+import type { OneResolvedTheme, OneThemeInitOptions } from './types';
+export interface NormalizedOneThemeOptions {
+    readonly themes: Readonly<Record<string, OneResolvedTheme>>;
+    readonly defaultTheme: string;
+}
+export declare function normalizeOneThemeOptions(options?: OneThemeInitOptions): NormalizedOneThemeOptions;

package/dist/theme/types.d.ts

@@ -0,0 +1,57 @@
+export interface OneThemeColors {
+    primary: string;
+    primaryHover: string;
+    primaryContrast: string;
+    secondary: string;
+    secondaryHover: string;
+    secondaryContrast: string;
+    danger: string;
+    dangerHover: string;
+    dangerContrast: string;
+    info: string;
+    success: string;
+    warning: string;
+    overlay: string;
+    surface: string;
+    text: string;
+    muted: string;
+    focus: string;
+}
+export interface OneThemeTypography {
+    fontFamily: string;
+    fontSizeSm: string;
+    fontSizeMd: string;
+    fontSizeLg: string;
+    lineHeight: string;
+}
+export interface OneThemeBorder {
+    color: string;
+    width: string;
+    style: string;
+}
+export interface OneThemeRadius {
+    sm: string;
+    md: string;
+    lg: string;
+}
+export interface OneThemeDefinition {
+    colors?: Partial<OneThemeColors>;
+    typography?: Partial<OneThemeTypography>;
+    border?: Partial<OneThemeBorder>;
+    radius?: Partial<OneThemeRadius>;
+}
+export interface OneResolvedTheme {
+    readonly colors: Readonly<OneThemeColors>;
+    readonly typography: Readonly<OneThemeTypography>;
+    readonly border: Readonly<OneThemeBorder>;
+    readonly radius: Readonly<OneThemeRadius>;
+}
+export interface OneThemeInitOptions {
+    themes?: Readonly<Record<string, OneThemeDefinition>>;
+    defaultTheme?: string;
+}
+export interface OneThemeService {
+    readonly currentTheme: string;
+    init(options?: OneThemeInitOptions): void;
+    switch(name: string): void;
+}

package/dist/theme/variables.d.ts

@@ -0,0 +1,6 @@
+import type { OneResolvedTheme } from './types';
+type OneThemeVariableReader = (theme: OneResolvedTheme) => string;
+type OneThemeVariable = readonly [string, OneThemeVariableReader];
+export declare const ONE_THEME_VARIABLES: readonly OneThemeVariable[];
+export declare function oneThemeToVariables(theme: OneResolvedTheme): ReadonlyArray<readonly [string, string]>;
+export {};

package/dist/tooltip/OneTooltip.d.ts

@@ -0,0 +1,45 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneTooltipProps } from './types';
+interface OneTooltipState {
+    internalOpen: boolean;
+}
+export declare class OneTooltip extends Component<OneTooltipProps, OneTooltipState> {
+    private readonly positioner;
+    private controller;
+    private triggerElement;
+    private targetDocument;
+    private previousDescribedBy;
+    private describedBySaved;
+    private tooltipId;
+    private hovered;
+    private focused;
+    private openTimer;
+    private closeTimer;
+    protected initState(): OneTooltipState;
+    protected initStyles(): void;
+    protected onMounted(): void;
+    protected beforeUpdate(): void;
+    protected beforeUnmount(): void;
+    protected render(): VNode;
+    private createBubble;
+    private synchronizeOverlay;
+    private bubbleOptions;
+    private requestedOpen;
+    private requestOpen;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private handleFocusIn;
+    private handleFocusOut;
+    private handleTriggerClick;
+    private readonly handleDocumentClick;
+    private readonly handleDocumentKeydown;
+    private scheduleOpen;
+    private scheduleClose;
+    private clearTimers;
+    private cancelOpenTimer;
+    private cancelCloseTimer;
+    private applyDescribedBy;
+    private restoreDescribedBy;
+    private normalizedTrigger;
+}
+export {};

package/dist/tooltip/TooltipBubble.d.ts

@@ -0,0 +1,29 @@
+import { Component, type VNode } from '@geektech/tsone';
+import type { OneOverlayPlacement, OneOverlayPositioner } from '../overlay';
+import { type OneNamedStyle } from '../styles/shared';
+export interface TooltipBubbleProps {
+    id: string;
+    content: VNode | string;
+    reference: HTMLElement;
+    placement: OneOverlayPlacement;
+    offset: number;
+    boundaryPadding: number;
+    arrow: boolean;
+    container: HTMLElement;
+    positioner: OneOverlayPositioner;
+}
+export declare const ONE_TOOLTIP_STYLES: OneNamedStyle[];
+interface TooltipBubbleState {
+}
+export declare class TooltipBubble extends Component<TooltipBubbleProps, TooltipBubbleState> {
+    private stopAutoUpdate;
+    mount(container: HTMLElement): void;
+    setProps(props: Partial<TooltipBubbleProps>): void;
+    protected initState(): TooltipBubbleState;
+    protected initStyles(): void;
+    protected onUnmounted(): void;
+    protected render(): VNode;
+    private updatePosition;
+    private boundaryRect;
+}
+export {};

package/dist/tooltip/index.d.ts

@@ -0,0 +1,4 @@
+export { OneTooltip } from './OneTooltip';
+export { ONE_TOOLTIP_STYLES, TooltipBubble } from './TooltipBubble';
+export type { TooltipBubbleProps } from './TooltipBubble';
+export type { OneTooltipProps, OneTooltipTrigger } from './types';

package/dist/tooltip/types.d.ts

@@ -0,0 +1,17 @@
+import type { VNode } from '@geektech/tsone';
+import type { OneOverlayContainer, OneOverlayPlacement } from '../overlay';
+export type OneTooltipTrigger = 'hover-focus' | 'click' | 'manual';
+export interface OneTooltipProps {
+    content: VNode | string;
+    placement?: OneOverlayPlacement;
+    trigger?: OneTooltipTrigger;
+    open?: boolean;
+    defaultOpen?: boolean;
+    openDelay?: number;
+    closeDelay?: number;
+    offset?: number;
+    container?: OneOverlayContainer;
+    arrow?: boolean;
+    disabled?: boolean;
+    children?: Array<VNode | string>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geektech/one",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "One UI 是基于 TSone 的轻量级纯 TypeScript UI 组件库",
   "type": "module",
   "main": "./dist/index.js",