@falcon-ui/falcon-ui 1.0.0

package/types/components/radial-menu/src/radial-menu.d.ts

@@ -0,0 +1,92 @@
+import type { ExtractPublicPropTypes, PropType } from 'vue';
+import type { FlRadialMenuCloseReason, FlRadialMenuDropdownPlacement, FlRadialMenuItemData, FlRadialMenuItemType, FlRadialMenuMode, FlRadialMenuMoreMode, FlRadialMenuOpenReason, FlRadialMenuResolvedItem, FlRadialMenuSelectContext, FlRadialMenuSize, FlRadialMenuTrigger } from './types';
+export declare const flRadialMenuProps: {
+    readonly items: {
+        readonly type: PropType<FlRadialMenuItemData[]>;
+        readonly default: () => never[];
+    };
+    readonly mode: {
+        readonly type: PropType<FlRadialMenuMode>;
+        readonly default: "inline";
+    };
+    readonly trigger: {
+        readonly type: PropType<FlRadialMenuTrigger>;
+        readonly default: "click";
+    };
+    readonly modelValue: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly shortcut: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly shortcutEnabled: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly centerIcon: {
+        readonly type: PropType<FlRadialMenuItemData["icon"]>;
+        readonly default: undefined;
+    };
+    readonly centerLabel: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly maxRingItems: {
+        readonly type: NumberConstructor;
+        readonly default: 6;
+    };
+    readonly closeOnSelect: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly moreText: {
+        readonly type: StringConstructor;
+        readonly default: "More";
+    };
+    readonly moreMode: {
+        readonly type: PropType<FlRadialMenuMoreMode>;
+        readonly default: "text-ellipsis";
+    };
+    readonly moreDropdownPlacement: {
+        readonly type: PropType<FlRadialMenuDropdownPlacement>;
+        readonly default: "bottom";
+    };
+    readonly size: {
+        readonly type: PropType<FlRadialMenuSize>;
+        readonly default: undefined;
+        readonly validator: (value: string) => boolean;
+    };
+    readonly itemType: {
+        readonly type: PropType<FlRadialMenuItemType>;
+        readonly default: "square";
+        readonly validator: (value: string) => boolean;
+    };
+    readonly teleport: {
+        readonly type: PropType<boolean | string>;
+        readonly default: true;
+    };
+    readonly zIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 2000;
+    };
+};
+export declare const flRadialMenuEmits: {
+    readonly 'update:modelValue': (opened: boolean) => boolean;
+    readonly open: (reason: FlRadialMenuOpenReason) => boolean;
+    readonly close: (reason: FlRadialMenuCloseReason) => boolean;
+    readonly select: (index: string, indexPath: string[], item: FlRadialMenuResolvedItem, context: FlRadialMenuSelectContext) => boolean;
+    readonly 'active-change': (item: FlRadialMenuResolvedItem | null) => boolean;
+    readonly 'more-open': () => boolean;
+    readonly 'more-close': () => boolean;
+};
+export type FlRadialMenuProps = ExtractPublicPropTypes<typeof flRadialMenuProps>;
+export type FlRadialMenuEmits = typeof flRadialMenuEmits;
+export type RadialMenuProps = FlRadialMenuProps;
+export type RadialMenuEmits = FlRadialMenuEmits;
+export type { FlRadialMenuCloseReason, FlRadialMenuDropdownPlacement, FlRadialMenuExpose, FlRadialMenuItemData, FlRadialMenuItemType, FlRadialMenuMode, FlRadialMenuMoreMode, FlRadialMenuOpenOptions, FlRadialMenuOpenReason, FlRadialMenuResolvableItem, FlRadialMenuResolvedItem, FlRadialMenuSelectContext, FlRadialMenuSize, FlRadialMenuTrigger } from './types';

package/types/components/radial-menu/src/radial-menu.vue.d.ts

@@ -0,0 +1,200 @@
+import { type Component } from 'vue';
+import type { FlRadialMenuExpose, FlRadialMenuResolvedItem, FlRadialMenuSize } from './types';
+type __VLS_Slots = {
+    default?: () => unknown;
+    center?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly items: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuItemData[]>;
+        readonly default: () => never[];
+    };
+    readonly mode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuMode>;
+        readonly default: "inline";
+    };
+    readonly trigger: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuTrigger>;
+        readonly default: "click";
+    };
+    readonly modelValue: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly shortcut: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly shortcutEnabled: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly centerIcon: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuItemData["icon"]>;
+        readonly default: undefined;
+    };
+    readonly centerLabel: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly maxRingItems: {
+        readonly type: NumberConstructor;
+        readonly default: 6;
+    };
+    readonly closeOnSelect: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly moreText: {
+        readonly type: StringConstructor;
+        readonly default: "More";
+    };
+    readonly moreMode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuMoreMode>;
+        readonly default: "text-ellipsis";
+    };
+    readonly moreDropdownPlacement: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuDropdownPlacement>;
+        readonly default: "bottom";
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<FlRadialMenuSize>;
+        readonly default: undefined;
+        readonly validator: (value: string) => boolean;
+    };
+    readonly itemType: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuItemType>;
+        readonly default: "square";
+        readonly validator: (value: string) => boolean;
+    };
+    readonly teleport: {
+        readonly type: import("vue").PropType<boolean | string>;
+        readonly default: true;
+    };
+    readonly zIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 2000;
+    };
+}>, FlRadialMenuExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (opened: boolean) => void;
+    close: (reason: import("@falcon-ui/falcon-ui").FlRadialMenuCloseReason) => void;
+    open: (reason: import("@falcon-ui/falcon-ui").FlRadialMenuOpenReason) => void;
+    select: (index: string, indexPath: string[], item: FlRadialMenuResolvedItem, context: import("@falcon-ui/falcon-ui").FlRadialMenuSelectContext) => void;
+    "active-change": (item: FlRadialMenuResolvedItem | null) => void;
+    "more-open": () => void;
+    "more-close": () => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly items: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuItemData[]>;
+        readonly default: () => never[];
+    };
+    readonly mode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuMode>;
+        readonly default: "inline";
+    };
+    readonly trigger: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuTrigger>;
+        readonly default: "click";
+    };
+    readonly modelValue: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly shortcut: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly shortcutEnabled: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly centerIcon: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuItemData["icon"]>;
+        readonly default: undefined;
+    };
+    readonly centerLabel: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly maxRingItems: {
+        readonly type: NumberConstructor;
+        readonly default: 6;
+    };
+    readonly closeOnSelect: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly moreText: {
+        readonly type: StringConstructor;
+        readonly default: "More";
+    };
+    readonly moreMode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuMoreMode>;
+        readonly default: "text-ellipsis";
+    };
+    readonly moreDropdownPlacement: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuDropdownPlacement>;
+        readonly default: "bottom";
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<FlRadialMenuSize>;
+        readonly default: undefined;
+        readonly validator: (value: string) => boolean;
+    };
+    readonly itemType: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").FlRadialMenuItemType>;
+        readonly default: "square";
+        readonly validator: (value: string) => boolean;
+    };
+    readonly teleport: {
+        readonly type: import("vue").PropType<boolean | string>;
+        readonly default: true;
+    };
+    readonly zIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 2000;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((opened: boolean) => any) | undefined;
+    onClose?: ((reason: import("@falcon-ui/falcon-ui").FlRadialMenuCloseReason) => any) | undefined;
+    onOpen?: ((reason: import("@falcon-ui/falcon-ui").FlRadialMenuOpenReason) => any) | undefined;
+    onSelect?: ((index: string, indexPath: string[], item: FlRadialMenuResolvedItem, context: import("@falcon-ui/falcon-ui").FlRadialMenuSelectContext) => any) | undefined;
+    "onActive-change"?: ((item: FlRadialMenuResolvedItem | null) => any) | undefined;
+    "onMore-open"?: (() => any) | undefined;
+    "onMore-close"?: (() => any) | undefined;
+}>, {
+    readonly size: FlRadialMenuSize;
+    readonly modelValue: boolean;
+    readonly zIndex: number;
+    readonly disabled: boolean;
+    readonly mode: import("@falcon-ui/falcon-ui").FlRadialMenuMode;
+    readonly trigger: import("@falcon-ui/falcon-ui").FlRadialMenuTrigger;
+    readonly shortcut: string;
+    readonly closeOnSelect: boolean;
+    readonly items: import("@falcon-ui/falcon-ui").FlRadialMenuItemData[];
+    readonly shortcutEnabled: boolean;
+    readonly centerIcon: string | Component | undefined;
+    readonly centerLabel: string;
+    readonly maxRingItems: number;
+    readonly moreText: string;
+    readonly moreMode: import("@falcon-ui/falcon-ui").FlRadialMenuMoreMode;
+    readonly moreDropdownPlacement: import("@falcon-ui/falcon-ui").FlRadialMenuDropdownPlacement;
+    readonly itemType: import("@falcon-ui/falcon-ui").FlRadialMenuItemType;
+    readonly teleport: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/components/radial-menu/src/types.d.ts

@@ -0,0 +1,48 @@
+import type { Component, Slot } from 'vue';
+export interface FlRadialMenuItemData {
+    index?: string;
+    key?: string | number;
+    label: string;
+    icon?: Component | string;
+    shortcut?: string;
+    disabled?: boolean;
+    hidden?: boolean;
+    divided?: boolean;
+    closeOnSelect?: boolean;
+    meta?: Record<string, unknown>;
+}
+export interface FlRadialMenuResolvableItem extends FlRadialMenuItemData {
+    iconSlot?: Slot;
+    labelSlot?: Slot;
+}
+export interface FlRadialMenuResolvedItem extends Omit<FlRadialMenuResolvableItem, 'index' | 'key' | 'icon'> {
+    index: string;
+    key?: string | number;
+    icon?: Component | string;
+    iconSlot?: Slot;
+    labelSlot?: Slot;
+}
+export type FlRadialMenuMode = 'inline' | 'floating';
+export type FlRadialMenuTrigger = 'click' | 'hover' | 'manual';
+export type FlRadialMenuMoreMode = 'ellipsis' | 'text' | 'text-ellipsis';
+export type FlRadialMenuDropdownPlacement = 'bottom' | 'top';
+export type FlRadialMenuSize = 'large' | 'medium' | 'small';
+export type FlRadialMenuItemType = 'square' | 'circle';
+export type FlRadialMenuOpenReason = 'click' | 'hover' | 'manual' | 'shortcut';
+export type FlRadialMenuCloseReason = 'click-outside' | 'select' | 'escape' | 'manual' | 'hover-leave';
+export interface FlRadialMenuOpenOptions {
+    x?: number;
+    y?: number;
+    reason?: FlRadialMenuOpenReason;
+}
+export interface FlRadialMenuSelectContext {
+    source: 'ring' | 'more';
+    index: number;
+    event: MouseEvent | KeyboardEvent;
+}
+export interface FlRadialMenuExpose {
+    open: (options?: FlRadialMenuOpenOptions) => void;
+    close: (reason?: FlRadialMenuCloseReason) => void;
+    toggle: (options?: FlRadialMenuOpenOptions) => void;
+    focus: () => void;
+}

package/types/components/radial-menu/src/use-radial-menu-items.d.ts

@@ -0,0 +1,19 @@
+import type { FlRadialMenuItemData, FlRadialMenuResolvableItem, FlRadialMenuResolvedItem } from './types';
+interface RadialMenuItemVisibility {
+    hidden?: boolean;
+}
+export interface RadialMenuSplitItems<T extends RadialMenuItemVisibility = FlRadialMenuResolvedItem> {
+    visibleItems: T[];
+    ringItems: T[];
+    moreItems: T[];
+    ringLimit: number;
+}
+export interface NormalizeRadialMenuItemsOptions {
+    warn?: (message: string) => void;
+}
+export declare const clampRingItemCount: (maxRingItems: number) => number;
+export declare const resolveRadialMenuItemIndex: (item: FlRadialMenuItemData) => string;
+export declare const normalizeRadialMenuItems: (items: FlRadialMenuResolvableItem[], options?: NormalizeRadialMenuItemsOptions) => FlRadialMenuResolvedItem[];
+export declare const splitRadialMenuItems: <T extends RadialMenuItemVisibility>(items: T[], maxRingItems: number) => RadialMenuSplitItems<T>;
+export declare const isRadialMenuItemDisabled: (item: FlRadialMenuResolvedItem | undefined) => boolean;
+export {};

package/types/components/radial-menu/src/use-radial-menu-keyboard.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from 'vue';
+import type { FlRadialMenuResolvedItem } from './types';
+export interface UseRadialMenuKeyboardOptions {
+    ringItems: Ref<FlRadialMenuResolvedItem[]>;
+    moreItems: Ref<FlRadialMenuResolvedItem[]>;
+    ringRefs: Ref<HTMLButtonElement[]>;
+    moreRefs: Ref<HTMLButtonElement[]>;
+    closeMenu: () => void;
+    closeMore: () => void;
+    activateFocused: (event: KeyboardEvent) => void;
+}
+export declare const useRadialMenuKeyboard: ({ ringItems, moreItems, ringRefs, moreRefs, closeMenu, closeMore, activateFocused }: UseRadialMenuKeyboardOptions) => {
+    focusFirstAvailableRingItem: () => void;
+    handleMenuKeydown: (event: KeyboardEvent) => void;
+    handleRingKeydown: (event: KeyboardEvent, index: number) => void;
+    handleMoreKeydown: (event: KeyboardEvent, index: number) => void;
+};

package/types/components/radial-menu/src/use-radial-menu-position.d.ts

@@ -0,0 +1,45 @@
+export interface RadialMenuItemLayoutOptions {
+    count: number;
+    index: number;
+    radius: number;
+    startAngle?: number;
+}
+export interface RadialMenuItemLayout {
+    angle: number;
+    x: number;
+    y: number;
+}
+export interface RadialMenuSectorPathOptions {
+    activeIndex: number;
+    count: number;
+    innerRadius: number;
+    outerRadius: number;
+    startAngle?: number;
+}
+export interface RadialMenuTrackArcPathOptions {
+    activeIndex: number;
+    count: number;
+    radius: number;
+    innerRadius?: number;
+    startAngle?: number;
+}
+export interface RadialMenuClockwiseArcPointsOptions {
+    radius: number;
+    targetAngle: number;
+    startAngle?: number;
+    steps?: number;
+}
+export interface RadialMenuClockwiseEntryOrderOptions {
+    startAngle?: number;
+}
+export type RadialMenuTipPlacement = 'left' | 'right' | 'top' | 'bottom';
+export declare const normalizeRadialMenuAngle: (angle: number) => number;
+export declare const getRadialMenuClockwiseArcPoints: ({ radius, targetAngle, startAngle, steps }: RadialMenuClockwiseArcPointsOptions) => {
+    x: number;
+    y: number;
+}[];
+export declare const getRadialMenuClockwiseEntryOrder: (layouts: Array<Pick<RadialMenuItemLayout, "angle">>, { startAngle }?: RadialMenuClockwiseEntryOrderOptions) => number[];
+export declare const getRadialMenuItemLayout: ({ count, index, radius, startAngle }: RadialMenuItemLayoutOptions) => RadialMenuItemLayout;
+export declare const getRadialMenuSectorPath: ({ activeIndex, count, innerRadius, outerRadius, startAngle }: RadialMenuSectorPathOptions) => string;
+export declare const getRadialMenuTrackArcPath: ({ activeIndex, count, radius, innerRadius, startAngle }: RadialMenuTrackArcPathOptions) => string;
+export declare const getRadialMenuTipPlacement: ({ x, y }: Pick<RadialMenuItemLayout, "x" | "y">) => RadialMenuTipPlacement;

package/types/components/radial-menu/src/use-radial-menu-shortcut.d.ts

@@ -0,0 +1,8 @@
+import { type Ref } from 'vue';
+import type { FlRadialMenuOpenOptions } from './types';
+export interface UseRadialMenuShortcutOptions {
+    shortcut: Ref<string>;
+    enabled: Ref<boolean>;
+    open: (options: FlRadialMenuOpenOptions) => void;
+}
+export declare const useRadialMenuShortcut: ({ shortcut, enabled, open }: UseRadialMenuShortcutOptions) => void;

package/types/components/radial-menu/src/use-radial-menu-state.d.ts

@@ -0,0 +1,15 @@
+import { type Ref } from 'vue';
+import type { FlRadialMenuCloseReason, FlRadialMenuOpenOptions } from './types';
+export interface UseRadialMenuStateOptions {
+    modelValue: Ref<boolean | undefined>;
+    disabled: Ref<boolean>;
+    emitUpdate: (opened: boolean) => void;
+}
+export declare const useRadialMenuState: ({ modelValue, disabled, emitUpdate }: UseRadialMenuStateOptions) => {
+    opened: import("vue").ComputedRef<boolean>;
+    floatingX: Ref<number | undefined, number | undefined>;
+    floatingY: Ref<number | undefined, number | undefined>;
+    open: (options?: FlRadialMenuOpenOptions) => void;
+    close: (_reason?: FlRadialMenuCloseReason) => void;
+    toggle: (options?: FlRadialMenuOpenOptions) => void;
+};

package/types/components/select/index.d.ts

@@ -0,0 +1,5 @@
+import Select from './src/select.vue';
+import type { SFCWithInstall } from '@falcon-ui/falcon-ui/utils';
+export declare const FlSelect: SFCWithInstall<typeof Select>;
+export default FlSelect;
+export type { FlSelectEmits, FlSelectExpose, FlSelectProps, SelectEmits, SelectExpose, SelectProps } from './src/select';

package/types/components/select/src/select.d.ts

@@ -0,0 +1,30 @@
+import type { ExtractPublicPropTypes } from 'vue';
+export declare const flSelectProps: {
+    /**
+     * 是否进入错误态。
+     */
+    readonly isError: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /**
+     * 是否用于表格单元格内选择场景。
+     */
+    readonly isTable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+};
+export declare const flSelectEmits: {};
+export type FlSelectProps = ExtractPublicPropTypes<typeof flSelectProps>;
+export type FlSelectEmits = typeof flSelectEmits;
+export interface FlSelectExpose {
+    focus: () => void;
+    blur: () => void;
+    selectedLabel?: string | string[];
+    toggleMenu?: (event?: Event) => void;
+    handleClearClick?: (event: Event) => void;
+}
+export type SelectProps = FlSelectProps;
+export type SelectEmits = FlSelectEmits;
+export type SelectExpose = FlSelectExpose;

package/types/components/select/src/select.vue.d.ts

@@ -0,0 +1,25 @@
+import type { FlSelectExpose } from './select';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly isError: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isTable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>, FlSelectExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly isError: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isTable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>> & Readonly<{}>, {
+    readonly isError: boolean;
+    readonly isTable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/types/components/table/index.d.ts

@@ -0,0 +1,8 @@
+import Table from './src/table.vue';
+import TableEditor from './src/table-editor.vue';
+import type { SFCWithInstall } from '@falcon-ui/falcon-ui/utils';
+export declare const FlTable: SFCWithInstall<typeof Table>;
+export declare const FlTableEditor: SFCWithInstall<typeof TableEditor>;
+export default FlTable;
+export type { CellChangeEvent, ColumnDragEvent, ColumnOrderChangeEvent, EmitTrigger, FlTableExpose, RowData, RowDragEvent, RowOrderChangeEvent, SelectionRowToggleEvent, SelectionSingleConflictEvent, TableExpose, TableEmits, TableProps } from './src/table';
+export type { TableEditorMode, TableEditorProps } from './src/table-editor';

package/types/components/table/src/editor-registry.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentPublicInstance } from 'vue';
+export type TableEditorMode = 'text' | 'controlled';
+export type TableEditorTarget = ComponentPublicInstance | HTMLElement | null;
+export type TableEditorEndpoint = {
+    id: symbol;
+    getRootEl: () => HTMLElement | null;
+    focus: () => void | Promise<void>;
+    blur: () => void | Promise<void>;
+    handoffFirstKey: (event: KeyboardEvent) => Promise<boolean>;
+    isPanelOpen?: () => boolean;
+    open?: () => void | Promise<void>;
+    close?: () => void | Promise<void>;
+    isFixedClone?: boolean;
+    priority?: number;
+};
+export type TableEditorRegistry = {
+    register: (endpoint: TableEditorEndpoint) => () => void;
+    getEditors: () => TableEditorEndpoint[];
+    getEditorsInCells: (cells: HTMLElement[]) => TableEditorEndpoint[];
+    invalidate: () => void;
+    refresh: () => void;
+};
+export declare const tableEditorRegistryDomKey: unique symbol;
+export declare const createTableEditorRegistry: () => TableEditorRegistry;

package/types/components/table/src/proxy-data.d.ts

@@ -0,0 +1,10 @@
+import type { CellChangeEvent, RowData } from './table';
+type BuildProxyDataOptions = {
+    data: RowData[];
+    onCellChange: (payload: CellChangeEvent) => void;
+    resolveRowIndex: (row: RowData) => number;
+    rowKeyField: string;
+    maxDepth: number;
+};
+export declare const createTableProxyDataBuilder: () => ({ data, onCellChange, resolveRowIndex, rowKeyField, maxDepth }: BuildProxyDataOptions) => RowData[];
+export {};

package/types/components/table/src/table-editor.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractPublicPropTypes, PropType, Ref } from 'vue';
+import type { TableEditorMode, TableEditorTarget } from './editor-registry';
+export declare const tableEditorProps: {
+    readonly mode: {
+        readonly type: PropType<TableEditorMode>;
+        readonly required: true;
+    };
+    readonly targetRef: {
+        readonly type: PropType<Ref<TableEditorTarget>>;
+        readonly default: undefined;
+    };
+    readonly priority: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+};
+export type TableEditorProps = ExtractPublicPropTypes<typeof tableEditorProps>;
+export type { TableEditorMode, TableEditorTarget };

package/types/components/table/src/table-editor.vue.d.ts

@@ -0,0 +1,43 @@
+import type { TableEditorTarget } from './editor-registry';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly mode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TableEditorMode>;
+        readonly required: true;
+    };
+    readonly targetRef: {
+        readonly type: import("vue").PropType<import("vue").Ref<TableEditorTarget>>;
+        readonly default: undefined;
+    };
+    readonly priority: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly mode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TableEditorMode>;
+        readonly required: true;
+    };
+    readonly targetRef: {
+        readonly type: import("vue").PropType<import("vue").Ref<TableEditorTarget>>;
+        readonly default: undefined;
+    };
+    readonly priority: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+}>> & Readonly<{}>, {
+    readonly targetRef: import("vue").Ref<TableEditorTarget, TableEditorTarget>;
+    readonly priority: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};