@opentiny/tiny-robot 0.4.2-alpha.9 → 0.5.1-alpha.1

package/dist/layout/components/LayoutSurface.vue.d.ts

@@ -0,0 +1,41 @@
+import { LayoutFloatingResizeDetail, LayoutFloatingState } from '../index.type';
+import { LayoutSurfaceProps } from '../internal.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        rootEl: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<LayoutSurfaceProps, {
+    rootEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:floatingState": (value: LayoutFloatingState) => any;
+    "floating-drag-start": (detail: LayoutFloatingState) => any;
+    "floating-drag": (detail: LayoutFloatingState) => any;
+    "floating-drag-end": (detail: LayoutFloatingState) => any;
+    "floating-resize-start": (detail: LayoutFloatingResizeDetail) => any;
+    "floating-resize": (detail: LayoutFloatingResizeDetail) => any;
+    "floating-resize-end": (detail: LayoutFloatingResizeDetail) => any;
+}, string, import('vue').PublicProps, Readonly<LayoutSurfaceProps> & Readonly<{
+    "onUpdate:floatingState"?: ((value: LayoutFloatingState) => any) | undefined;
+    "onFloating-drag-start"?: ((detail: LayoutFloatingState) => any) | undefined;
+    "onFloating-drag"?: ((detail: LayoutFloatingState) => any) | undefined;
+    "onFloating-drag-end"?: ((detail: LayoutFloatingState) => any) | undefined;
+    "onFloating-resize-start"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+    "onFloating-resize"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+    "onFloating-resize-end"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootEl: HTMLDivElement;
+}, 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/layout/composables/useLayoutAsideStates.d.ts

@@ -0,0 +1,21 @@
+import { MaybeRefOrGetter } from '@vueuse/core';
+import { LayoutAsideOpenDetail, LayoutAsideOptions, LayoutAsideResizeDetail, LayoutSide } from '../index.type';
+import { LayoutAsideState } from '../internal.type';
+interface UseLayoutAsideStateOptions {
+    side: LayoutSide;
+    config: MaybeRefOrGetter<LayoutAsideOptions | undefined>;
+    onOpenChange?: (detail: LayoutAsideOpenDetail) => void;
+    onExpandedWidthChange?: (detail: LayoutAsideResizeDetail) => void;
+}
+interface UseLayoutAsideStatesOptions {
+    leftConfig: MaybeRefOrGetter<LayoutAsideOptions | undefined>;
+    rightConfig: MaybeRefOrGetter<LayoutAsideOptions | undefined>;
+    onOpenChange?: (detail: LayoutAsideOpenDetail) => void;
+    onExpandedWidthChange?: (detail: LayoutAsideResizeDetail) => void;
+}
+export declare function useLayoutAsideState(options: UseLayoutAsideStateOptions): LayoutAsideState;
+export declare function useLayoutAsideStates(options: UseLayoutAsideStatesOptions): {
+    leftAsideState: LayoutAsideState;
+    rightAsideState: LayoutAsideState;
+};
+export {};

package/dist/layout/composables/useLayoutContext.d.ts

@@ -0,0 +1,4 @@
+import { LayoutContext } from '../internal.type';
+export declare function provideLayoutContext(context: LayoutContext): void;
+export declare function useLayoutContext(): LayoutContext;
+export declare function useLayoutAsideContext(side: 'left' | 'right'): import('../internal.type').LayoutAsideToggleContext;

package/dist/layout/composables/usePointerDrag.d.ts

@@ -0,0 +1,19 @@
+import { MaybeRefOrGetter } from '@vueuse/core';
+import { ComputedRef } from 'vue';
+export type PointerDragEndReason = 'pointerup' | 'pointercancel' | 'manual' | 'scope-dispose';
+export interface PointerDragEndDetail {
+    reason: PointerDragEndReason;
+    event?: PointerEvent;
+}
+export interface UsePointerDragOptions<T> {
+    disabled?: MaybeRefOrGetter<boolean>;
+    buttons?: MaybeRefOrGetter<readonly number[]>;
+    onStart: (event: PointerEvent) => T | false | null | undefined;
+    onMove?: (context: T, event: PointerEvent) => void;
+    onEnd?: (context: T, detail: PointerDragEndDetail) => void;
+}
+export interface UsePointerDragReturn {
+    isDragging: ComputedRef<boolean>;
+    cancel: () => void;
+}
+export declare function usePointerDrag<T>(handle: MaybeRefOrGetter<HTMLElement | null | undefined>, options: UsePointerDragOptions<T>): UsePointerDragReturn;

package/dist/layout/index.d.ts

@@ -0,0 +1,22 @@
+import { App } from 'vue';
+import { default as LayoutComp } from './Layout.vue';
+import { default as LayoutAsideToggleComp } from './LayoutAsideToggle.vue';
+import { default as LayoutProxyScrollbarComp } from './LayoutProxyScrollbar.vue';
+export * from './index.type';
+declare const layoutProxyScrollbarInstall: <T>(app: App<T>) => void;
+declare const LayoutProxyScrollbar: typeof LayoutProxyScrollbarComp & {
+    install: typeof layoutProxyScrollbarInstall;
+};
+declare const layoutAsideToggleInstall: <T>(app: App<T>) => void;
+declare const LayoutAsideToggle: typeof LayoutAsideToggleComp & {
+    install: typeof layoutAsideToggleInstall;
+};
+declare const layoutInstall: <T>(app: App<T>) => void;
+type LayoutCompound = typeof LayoutComp & {
+    install: typeof layoutInstall;
+    ProxyScrollbar: typeof LayoutProxyScrollbar;
+    AsideToggle: typeof LayoutAsideToggle;
+};
+declare const Layout: LayoutCompound;
+export { Layout, LayoutProxyScrollbar, LayoutAsideToggle };
+export default Layout;