@opentiny/tiny-robot 0.4.2-alpha.3 → 0.4.2-alpha.5

package/dist/anchor/index.vue.d.ts

@@ -0,0 +1,159 @@
+import { AnchorProps, AnchorSlots } from './index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AnchorSlots> & AnchorSlots;
+    refs: {
+        overlayShellRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly expanded: boolean;
+                readonly placement: import('./index.type').AnchorPlacement;
+                readonly floatingOffset?: number | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                hostEl: HTMLDivElement;
+                overlayEl: HTMLDivElement;
+                navEl: HTMLElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, {
+                hostEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                overlayEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                navEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                floatingOffset: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            floatingOffset: number;
+        }> & Omit<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, "floatingOffset" | "hostEl" | "overlayEl" | "navEl"> & {
+            hostEl: HTMLElement | null;
+            overlayEl: HTMLElement | null;
+            navEl: HTMLElement | null;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                search?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AnchorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (item: import('./index.type').AnchorItem) => any;
+    "update:searchQuery": (value: string) => any;
+    "update:activeId": (value: string | undefined) => any;
+    "update:expanded": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<AnchorProps> & Readonly<{
+    onSelect?: ((item: import('./index.type').AnchorItem) => any) | undefined;
+    "onUpdate:searchQuery"?: ((value: string) => any) | undefined;
+    "onUpdate:activeId"?: ((value: string | undefined) => any) | undefined;
+    "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
+}>, {
+    placement: import('./index.type').AnchorPlacement;
+    tooltipDelay: number;
+    emptyText: string;
+    activeOffset: number;
+    expandTrigger: import('./index.type').AnchorExpandTrigger;
+    targetFeedbackDuration: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    overlayShellRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly expanded: boolean;
+            readonly placement: import('./index.type').AnchorPlacement;
+            readonly floatingOffset?: number | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            hostEl: HTMLDivElement;
+            overlayEl: HTMLDivElement;
+            navEl: HTMLElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, {
+            hostEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            overlayEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            navEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            floatingOffset: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        floatingOffset: number;
+    }> & Omit<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, "floatingOffset" | "hostEl" | "overlayEl" | "navEl"> & {
+        hostEl: HTMLElement | null;
+        overlayEl: HTMLElement | null;
+        navEl: HTMLElement | null;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            search?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/anchor/internal.type.d.ts

@@ -0,0 +1,103 @@
+import { Ref } from 'vue';
+import { AnchorExpandTrigger, AnchorHighlightSegment, AnchorItem, AnchorPlacement, AnchorSearchOptions } from './index.type';
+export interface AnchorFilteredItem {
+    item: AnchorItem;
+    segments: AnchorHighlightSegment[];
+}
+export interface AnchorItemSlotProps {
+    item: AnchorItem;
+    segments: AnchorFilteredItem['segments'];
+    active: boolean;
+    expanded: boolean;
+    highlighted: boolean;
+}
+export interface AnchorMarkerSlotProps {
+    item: AnchorItem;
+    active: boolean;
+}
+export interface AnchorSearchProps {
+    searchQuery: string;
+    searchOptions?: AnchorSearchOptions;
+}
+export interface AnchorSearchEmits {
+    'update:searchQuery': [value: string];
+}
+export interface AnchorOverlayProps {
+    expanded: boolean;
+    placement: AnchorPlacement;
+    floatingOffset?: number;
+}
+export interface AnchorOverlayExpose {
+    hostEl: HTMLElement | null;
+    overlayEl: HTMLElement | null;
+    navEl: HTMLElement | null;
+}
+export interface AnchorListProps {
+    items: AnchorFilteredItem[];
+    activeId?: string;
+    expanded: boolean;
+    highlightedIndex: number;
+    placement: AnchorPlacement;
+    tooltipDelay: number;
+    emptyText: string;
+}
+export interface AnchorListEmits {
+    select: [item: AnchorItem];
+}
+export interface AnchorListSlots {
+    item?: (slotProps: AnchorItemSlotProps) => unknown;
+    marker?: (slotProps: AnchorMarkerSlotProps) => unknown;
+    empty?: () => unknown;
+}
+export interface AnchorItemProps {
+    entry: AnchorFilteredItem;
+    activeId?: string;
+    expanded: boolean;
+    highlighted: boolean;
+    placement: AnchorPlacement;
+    tooltipDelay: number;
+}
+export interface AnchorItemEmits {
+    select: [item: AnchorItem];
+}
+export interface AnchorItemSlots {
+    item?: (slotProps: AnchorItemSlotProps) => unknown;
+    marker?: (slotProps: AnchorMarkerSlotProps) => unknown;
+}
+export interface AnchorActiveSyncOptions {
+    items: Ref<AnchorItem[]>;
+    resolveTarget: (id: string) => HTMLElement | null;
+    container: Ref<HTMLElement | null | undefined>;
+    host?: Ref<HTMLElement | null | undefined>;
+    activeId?: Ref<string | undefined>;
+    activeOffset?: Ref<number | undefined>;
+    onUpdateActiveId?: (value: string | undefined) => void;
+}
+export interface AnchorFloatingOffsetOptions {
+    container: Ref<HTMLElement | null | undefined>;
+    host: Ref<HTMLElement | null | undefined>;
+}
+export interface AnchorOverlayInteractionsOptions {
+    overlay: Ref<AnchorOverlayExpose | null>;
+    highlightedId: Ref<string | undefined>;
+    shouldAutoCollapse: Ref<boolean>;
+    handleNavigationKeydown: (event: KeyboardEvent) => boolean;
+    getHighlightedItem: () => AnchorItem | undefined;
+    onSelectItem: (itemId: string) => void;
+    setExpanded: (value: boolean) => void;
+}
+export interface AnchorControllerOptions {
+    items: Ref<AnchorItem[]>;
+    activeId: Ref<string | undefined>;
+    expanded: Ref<boolean | undefined>;
+    expandTrigger: Ref<AnchorExpandTrigger>;
+    searchQuery?: Ref<string | undefined>;
+    searchOptions?: Ref<AnchorSearchOptions | undefined>;
+    onUpdateExpanded?: (value: boolean) => void;
+    onUpdateSearchQuery?: (value: string) => void;
+}
+export interface AnchorTargetFeedbackOptions {
+    resolveTarget: (id: string) => HTMLElement | null;
+    feedbackClass: Ref<string | undefined>;
+    feedbackDuration: Ref<number | undefined>;
+}

package/dist/anchor/utils/scroll.d.ts

@@ -0,0 +1,7 @@
+export type AnchorScrollRoot = HTMLElement | Window;
+export declare function resolveAnchorScrollRoot(container: HTMLElement | null | undefined): AnchorScrollRoot | null;
+export declare function getAnchorScrollTop(root: AnchorScrollRoot | null): number;
+export declare function getAnchorClientHeight(root: AnchorScrollRoot | null): number;
+export declare function getAnchorScrollHeight(root: AnchorScrollRoot | null): number;
+export declare function getAnchorViewportTop(root: AnchorScrollRoot | null): number;
+export declare function scrollAnchorTo(root: AnchorScrollRoot | null, top: number, behavior: ScrollBehavior): void;

package/dist/anchor/utils/target.d.ts

@@ -0,0 +1,6 @@
+export declare const ANCHOR_TARGET_ATTRIBUTE = "data-anchor-id";
+export declare const ANCHOR_TARGET_SELECTOR = "[data-anchor-id]";
+export declare const ANCHOR_ITEM_ATTRIBUTE = "data-item-id";
+export declare const ANCHOR_ITEM_SELECTOR = "[data-item-id]";
+export declare function queryAnchorTargetById(root: ParentNode, id: string): HTMLElement | undefined;
+export declare function queryAnchorItemById(root: ParentNode, id: string): HTMLElement | undefined;

package/dist/attachments/components/FileCard.vue.d.ts

@@ -0,0 +1,18 @@
+import { FileCardProps } from '../index.type';
+declare const _default: import('vue').DefineComponent<FileCardProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: (...args: any[]) => void;
+    download: (...args: any[]) => void;
+    retry: (...args: any[]) => void;
+    preview: (...args: any[]) => void;
+    action: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<FileCardProps> & Readonly<{
+    onRemove?: ((...args: any[]) => any) | undefined;
+    onDownload?: ((...args: any[]) => any) | undefined;
+    onRetry?: ((...args: any[]) => any) | undefined;
+    onPreview?: ((...args: any[]) => any) | undefined;
+    onAction?: ((...args: any[]) => any) | undefined;
+}>, {
+    variant: "picture" | "card";
+    showStatus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/attachments/components/ImagePreview.vue.d.ts

@@ -0,0 +1,17 @@
+import { Attachment } from '../index.type';
+type Image = Pick<Attachment, 'id' | 'name' | 'url'>;
+interface ImagePreviewProps {
+    images: Image[];
+}
+type __VLS_Props = ImagePreviewProps;
+type __VLS_PublicProps = {
+    'currentIndex': number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    "update:currentIndex": (value: number) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    "onUpdate:currentIndex"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/attachments/components/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FileCard } from './FileCard.vue';
+export { default as ImagePreview } from './ImagePreview.vue';

package/dist/attachments/composables/index.d.ts

@@ -0,0 +1,5 @@
+import { useFileType } from './useFileType';
+import { useFileCard } from './useFileCard';
+import { useImagePreview } from './useImagePreview';
+import { useListType } from './useListType';
+export { useFileType, useFileCard, useImagePreview, useListType };

package/dist/attachments/composables/useFileCard.d.ts

@@ -0,0 +1,15 @@
+import { ActionButton, FileCardProps, FileCardEmits } from '../index.type';
+/**
+ * 管理文件卡片交互逻辑
+ * @param props 组件属性
+ * @param emit 组件事件触发器
+ * @returns 交互处理器
+ */
+export declare function useFileCard(props: FileCardProps, emit: FileCardEmits): {
+    isImage: import('vue').ComputedRef<boolean>;
+    handlePreview: (event: MouseEvent) => void;
+    downloadFile: (event: MouseEvent) => void;
+    handleRemove: () => void;
+    handleRetry: () => void;
+    handleCustomAction: (action: ActionButton, event: MouseEvent) => void;
+};

package/dist/attachments/composables/useFileType.d.ts

@@ -0,0 +1,20 @@
+import { Component, ComputedRef } from 'vue';
+import { FileType, FileTypeMatcher, Attachment } from '../index.type';
+interface UseFileTypeOptions {
+    /**
+     * 自定义图标
+     */
+    customIcons?: Record<string, Component>;
+    /**
+     * 自定义文件类型匹配器
+     */
+    fileMatchers?: FileTypeMatcher[];
+}
+export declare function useFileType(options?: UseFileTypeOptions): {
+    detectFileType: (file: File | string) => FileType;
+    generateID: () => string;
+    formatFileSize: (size: number) => string;
+    normalizeAttachments: (items: (Attachment | Partial<Attachment>)[]) => Attachment[];
+    getIconComponent: (fileType?: FileType) => ComputedRef<Component>;
+};
+export {};

package/dist/attachments/composables/useImagePreview.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { Attachment, AttachmentListEmits } from '../index.type';
+export interface ImagePreviewOptions {
+    /**
+     * 是否启用下载功能
+     */
+    enableDownload?: boolean;
+    /**
+     * 自定义下载处理函数
+     */
+    onDownload?: (event: MouseEvent, file: Attachment) => void;
+}
+export declare function useImagePreview(fileList: Ref<Attachment[]>, emit: AttachmentListEmits, options?: ImagePreviewOptions): {
+    handlePreview: (event: MouseEvent, file: Attachment) => void;
+    renderPreview: () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }> | null;
+};

package/dist/attachments/composables/useListType.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { Attachment, DisplayVariant } from '../index.type';
+/**
+ * 处理listType自动检测的组合函数
+ * @param fileList 文件列表的响应式引用
+ * @param specifiedListType 用户指定的listType
+ * @returns 实际使用的listType
+ */
+export declare function useListType(fileList: Ref<Attachment[]>, specifiedListType?: DisplayVariant): {
+    actualListType: import('vue').ComputedRef<"picture" | "card">;
+};

package/dist/attachments/index.d.ts

@@ -0,0 +1,7 @@
+import { App } from 'vue';
+import { default as Attachments } from './index.vue';
+declare const install: <T>(app: App<T>) => void;
+declare const _default: typeof Attachments & {
+    install: typeof install;
+};
+export default _default;