@leaflink/stash 50.4.0 → 50.5.0

package/dist/ThumbnailGroup.vue.d.ts

@@ -0,0 +1,191 @@
+import { AllowedComponentProps } from 'vue';
+import { ComponentCustomProps } from 'vue';
+import { ComputedRef } from 'vue';
+import { MaybeRefOrGetter } from 'vue';
+import { Ref } from 'vue';
+import { RendererElement } from 'vue';
+import { RendererNode } from 'vue';
+import { ShallowUnwrapRef } from 'vue';
+import { VNode } from 'vue';
+import { VNodeProps } from 'vue';
+
+declare const _default: <Thumbnail extends ThumbnailDefinition>(__VLS_props: {
+    radius?: ThumbnailRadius | undefined;
+    draggable?: boolean | undefined;
+    removable?: boolean | undefined;
+    thumbnails?: Thumbnail[] | undefined;
+    activeThumbnail?: number | undefined;
+    readonly onDragStart?: ((event: SortableOnDragStartEvent) => any) | undefined;
+    readonly onDragEnd?: ((event: SortableDragEvent) => any) | undefined;
+    readonly "onUpdate:thumbnails"?: ((thumbnails: Thumbnail[]) => any) | undefined;
+    showEmpty?: boolean | undefined;
+    emptyOptions?: ThumbnailEmptyOptions | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps, __VLS_ctx?: {
+    attrs: any;
+    slots: {
+        default?(_: {
+            activeThumbnail: number;
+            isDragging: boolean;
+        }): any;
+    };
+    emit: ((evt: "dragStart", event: SortableOnDragStartEvent) => void) & ((evt: "dragEnd", event: SortableDragEvent) => void) & ((evt: "update:thumbnails", thumbnails: Thumbnail[]) => void);
+} | undefined, __VLS_expose?: ((exposed: ShallowUnwrapRef<    {}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        radius?: ThumbnailRadius | undefined;
+        draggable?: boolean | undefined;
+        removable?: boolean | undefined;
+        thumbnails?: Thumbnail[] | undefined;
+        activeThumbnail?: number | undefined;
+        readonly onDragStart?: ((event: SortableOnDragStartEvent) => any) | undefined;
+        readonly onDragEnd?: ((event: SortableDragEvent) => any) | undefined;
+        readonly "onUpdate:thumbnails"?: ((thumbnails: Thumbnail[]) => any) | undefined;
+        showEmpty?: boolean | undefined;
+        emptyOptions?: ThumbnailEmptyOptions | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+    expose(exposed: ShallowUnwrapRef<    {}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {
+            activeThumbnail: number;
+            isDragging: boolean;
+        }): any;
+    };
+    emit: ((evt: "dragStart", event: SortableOnDragStartEvent) => void) & ((evt: "dragEnd", event: SortableDragEvent) => void) & ((evt: "update:thumbnails", thumbnails: Thumbnail[]) => void);
+}>) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            radius?: ThumbnailRadius | undefined;
+            draggable?: boolean | undefined;
+            removable?: boolean | undefined;
+            thumbnails?: Thumbnail[] | undefined;
+            activeThumbnail?: number | undefined;
+            readonly onDragStart?: ((event: SortableOnDragStartEvent) => any) | undefined;
+            readonly onDragEnd?: ((event: SortableDragEvent) => any) | undefined;
+            readonly "onUpdate:thumbnails"?: ((thumbnails: Thumbnail[]) => any) | undefined;
+            showEmpty?: boolean | undefined;
+            emptyOptions?: ThumbnailEmptyOptions | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        expose(exposed: ShallowUnwrapRef<    {}>): void;
+        attrs: any;
+        slots: {
+            default?(_: {
+                activeThumbnail: number;
+                isDragging: boolean;
+            }): any;
+        };
+        emit: ((evt: "dragStart", event: SortableOnDragStartEvent) => void) & ((evt: "dragEnd", event: SortableDragEvent) => void) & ((evt: "update:thumbnails", thumbnails: Thumbnail[]) => void);
+    } | undefined;
+};
+export default _default;
+
+/**
+ * Move sortable elements in the list
+ * @param list List of sortable elements
+ * @param from Original element position
+ * @param to New element position
+ */
+export declare function moveSortableElements<ListItem>({ list, from, to }: MoveSortableElementsOptions<ListItem>): void;
+
+export declare interface MoveSortableElementsOptions<T> {
+    list: RefOrGetter<T[]>;
+    from: number;
+    to: number;
+}
+
+/**
+ * Like the MaybeRefOrGetter type from Vue, but without the Maybe. Can be used to ensure the most up-to-date value is available.
+ */
+declare type RefOrGetter<T> = Ref<T> | (() => T);
+
+export declare interface SortableDragEvent extends DragEvent {
+    /**
+     * The old index of the dragged element
+     */
+    oldIndex: number;
+    /**
+     * The new index of the dragged element
+     */
+    newIndex: number;
+}
+
+export declare type SortableOnDragEndEvent = SortableDragEvent;
+
+export declare type SortableOnDragStartEvent = Omit<SortableDragEvent, 'newIndex'>;
+
+declare interface ThumbnailDefinition {
+    id: number | string;
+    imageUrl: string;
+}
+
+export declare interface ThumbnailEmptyOptions {
+    max: number;
+}
+
+export declare interface ThumbnailInjection<Thumbnail> {
+    isDragging: MaybeRefOrGetter<boolean>;
+    radius: ThumbnailRadius;
+    draggable: ComputedRef<boolean>;
+    removable: MaybeRefOrGetter<boolean>;
+    thumbnails: MaybeRefOrGetter<Thumbnail[]>;
+    activeThumbnail: Ref<number | undefined>;
+}
+
+export declare type ThumbnailRadius = 'rounded' | 'circle';
+
+export declare interface UseSortableOptions<SortableItem> {
+    /**
+     * The parent element of the sortable elements
+     */
+    ref: Ref<HTMLElement | null>;
+    /**
+     * The list of sortable elements to be sorted
+     */
+    list: Ref<SortableItem[]>;
+    /**
+     * Enables/Disables drag and drop sorting
+     * @default true
+     */
+    isEnabled?: boolean;
+    /**
+     * Class name for the ghost element
+     * @default ''
+     */
+    ghostClass?: string;
+    /**
+     * Class name for the chosen element
+     * @default ''
+     */
+    chosenClass?: string;
+    /**
+     * Sort the list in place
+     * @default true
+     */
+    sortInPlace?: boolean;
+    /**
+     * Callback when the dragging starts
+     */
+    onDragStart?: (e: SortableOnDragStartEvent) => void;
+    /**
+     * Callback when the dragging ends
+     */
+    onDragEnd?: (e: SortableOnDragEndEvent) => void;
+}
+
+export declare interface UseSortableReturn {
+    /**
+     * Whether the element is currently being dragged
+     */
+    isDragging: Ref<boolean>;
+    /**
+     * The new position of the dragged element
+     */
+    newIndex: Ref<number>;
+    /**
+     * The original position of the dragged element
+     */
+    oldIndex: Ref<number>;
+}
+
+export { }

package/dist/Tooltip.js

@@ -1,6 +1,6 @@
-import { defineComponent as g, ref as n, computed as r, openBlock as d, createElementBlock as S, createElementVNode as i, renderSlot as l, createBlock as T, Teleport as E, normalizeStyle as u, unref as $, createTextVNode as k, toDisplayString as O } from "vue";
+import { defineComponent as g, ref as n, computed as r, openBlock as d, createElementBlock as S, createElementVNode as i, renderSlot as l, createBlock as T, Teleport as E, normalizeStyle as f, unref as $, createTextVNode as k, toDisplayString as O } from "vue";
 import { u as A, a as B, f as F, o as D, b as I } from "./floating-ui.vue-BmfQDqE-.js";
-import { u as P } from "./index-Ck3Dl09q.js";
+import { a as P } from "./index-Bbc2pg2X.js";
 const z = {
   ref: "wrapper",
   class: "stash-tooltip__wrapper tw-relative tw-inline-flex tw-h-fit tw-w-fit"
@@ -13,13 +13,13 @@ const z = {
     teleportTo: { default: "#stash-menus-mount-node" },
     text: { default: "" }
   },
-  setup(f) {
+  setup(u) {
     const m = {
       top: "bottom",
       right: "left",
       bottom: "top",
       left: "right"
-    }, e = f, a = n(null), p = n(null), c = n(null), { isOutside: h } = P(a), _ = r(() => !h.value || e.isOpen), y = r(() => e.side), { floatingStyles: x, middlewareData: o, placement: v } = A(a, c, {
+    }, e = u, a = n(null), p = n(null), c = n(null), { isOutside: h } = P(a), _ = r(() => !h.value || e.isOpen), y = r(() => e.side), { floatingStyles: x, middlewareData: o, placement: v } = A(a, c, {
       whileElementsMounted: B,
       placement: y,
       middleware: [F(), D(N), I({ element: p })]
@@ -51,7 +51,7 @@ const z = {
           "data-test": "stash-tooltip",
           class: "stash-tooltip tw-pointer-events-none tw-z-screen tw-flex tw-w-[148px] tw-flex-col tw-items-center tw-whitespace-normal tw-rounded tw-bg-ice-900 tw-p-3 tw-text-center tw-text-xs tw-text-white tw-opacity-0 tw-shadow tw-transition-opacity",
           role: "tooltip",
-          style: u({
+          style: f({
             ...$(x),
             opacity: _.value ? 0.95 : 0
           })
@@ -65,7 +65,7 @@ const z = {
             ref_key: "floatingArrow",
             ref: p,
             class: "stash-tooltip__arrow tw-absolute tw-z-behind tw-h-[12px] tw-w-[12px] tw-rotate-45 tw-bg-ice-900",
-            style: u(b.value)
+            style: f(b.value)
           }, null, 4)
         ], 4)
       ], 8, ["to", "disabled"]))