@codingfactory/mediables-vue 2.15.0 → 2.17.0

package/dist/components/MediaTrashWorkspace.vue.d.ts

@@ -0,0 +1,15 @@
+import type { MediaLibraryHttpClient } from '../types/mediaLibraryPicker';
+export interface MediaTrashWorkspaceLabels {
+    title?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    restore?: string;
+    purge?: string;
+    emptyTrash?: string;
+}
+export interface MediaTrashWorkspaceProps {
+    httpClient: MediaLibraryHttpClient;
+    labels?: MediaTrashWorkspaceLabels;
+}
+declare const _default: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, string, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>;
+export default _default;

package/dist/components/MediaUsageList.vue.d.ts

@@ -0,0 +1,17 @@
+import type { Media } from '../types/media';
+import type { MediaLibraryHttpClient } from '../types/mediaLibraryPicker';
+export interface MediaUsageListItem {
+    id: string;
+    label: string;
+    href?: string;
+    count?: number;
+}
+export interface MediaUsageListProps {
+    media: Media | null;
+    httpClient?: MediaLibraryHttpClient;
+    items?: MediaUsageListItem[];
+    title?: string;
+    emptyLabel?: string;
+}
+declare const _default: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, string, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>;
+export default _default;

package/dist/components/MediaVariantStrip.vue.d.ts

@@ -0,0 +1,10 @@
+import type { Media } from '../types/media';
+import type { MediaLibraryHttpClient } from '../types/mediaLibraryPicker';
+export interface MediaVariantStripProps {
+    media: Media | null;
+    httpClient?: MediaLibraryHttpClient;
+    variants?: Media[];
+    title?: string;
+}
+declare const _default: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, string, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>;
+export default _default;

package/dist/composables/useAlbums.d.ts

@@ -1,5 +1,6 @@
 import type { Ref } from 'vue';
-import type { Album } from '@/types/album';
+import type { Album, CreateAlbumPayload, UpdateAlbumPayload } from '@/types/album';
+import type { Media } from '@/types/media';
 export interface FetchAlbumsParams {
     parent_id?: string | null;
 }
@@ -10,6 +11,14 @@ export interface UseAlbumsReturn {
     loading: Ref<boolean>;
     error: Ref<string | null>;
     fetchAlbums: (params?: FetchAlbumsParams) => Promise<void>;
+    fetchAlbum: (albumId: string) => Promise<Album>;
+    fetchAlbumMedia: (albumId: string) => Promise<Media[]>;
+    attachMedia: (albumId: string, mediaIds: string[], orderColumn?: number) => Promise<Album>;
+    detachMedia: (albumId: string, mediaId: string) => Promise<void>;
+    reorderAlbumMedia: (albumId: string, orderedIds: string[]) => Promise<void>;
+    createAlbum: (payload: CreateAlbumPayload) => Promise<Album>;
+    updateAlbum: (albumId: string, payload: UpdateAlbumPayload) => Promise<Album>;
+    deleteAlbum: (albumId: string) => Promise<void>;
     getChildrenOf: (parentId: string | null) => Album[];
     childrenLoaded: (parentId: string) => boolean;
     moveAlbum: (albumId: string, newParentId: string | null) => Promise<void>;

package/dist/composables/useMediaDeletion.d.ts

@@ -37,6 +37,29 @@ export interface BatchDeleteResponse {
     results: BatchDeleteResultItem[];
     summary: Partial<Record<BatchDeleteItemStatus, number>>;
 }
+/**
+ * Thrown when the backend reports `requires_confirmation: true` on a
+ * deletion attempt — the host UI should present the {@link softBlocks}
+ * to the user, then retry `deleteMany()` with `{ confirmed: true }`.
+ *
+ * Hard blocks (published galleries, etc.) raise a regular HTTP error
+ * with `blocks` and are surfaced via the underlying http client's
+ * standard rejection — they are never bypassable via this flow.
+ */
+export declare class RequiresConfirmationError extends Error {
+    /** Per-uuid soft blocks the user must acknowledge. */
+    readonly softBlocks: Record<string, DeletionBlock[]>;
+    constructor(softBlocks: Record<string, DeletionBlock[]>, message?: string);
+}
+/**
+ * Per-item view of a soft block, suitable for rendering a confirmation
+ * prompt. Hosts that inject a `confirmDestructiveAction` callback receive
+ * an array of these (one entry per affected media uuid).
+ */
+export interface SoftBlock {
+    uuid: string;
+    blocks: DeletionBlock[];
+}
 export interface UseMediaDeletionOptions {
     httpClient: MediaLibraryHttpClient;
     /** Endpoint paths — overridable for apps with non-default routes (e.g., admin namespace). */
@@ -50,8 +73,21 @@ export interface UseMediaDeletionReturn {
     lastResponse: Ref<BatchDeleteResponse | null>;
     error: Ref<Error | null>;
     checkDependencies: (uuids: string[]) => Promise<DependencyReport[]>;
+    /**
+     * Trigger the batch-delete endpoint.
+     *
+     * - `force` — request the server bypass hard dependency blocks (e.g.,
+     *   admin override). Default `false`.
+     * - `confirmed` — acknowledge soft (confirmation-required) blocks
+     *   surfaced via {@link RequiresConfirmationError}. Default `false`.
+     *
+     * If the backend responds 409 with `requires_confirmation: true`, this
+     * call rejects with a {@link RequiresConfirmationError} so the UI can
+     * present the soft blocks and retry with `{ confirmed: true }`.
+     */
     deleteMany: (uuids: string[], options?: {
         force?: boolean;
+        confirmed?: boolean;
     }) => Promise<BatchDeleteResponse>;
     reset: () => void;
 }

package/dist/composables/useMediaDisplayName.d.ts

@@ -0,0 +1,19 @@
+import type { Media } from '../types/media';
+export declare function cleanFileLikeName(value: string): string;
+/**
+ * Resolve a human-readable display name for a Media row.
+ *
+ * Priority (per plan §14b.10):
+ *   1. `custom_properties.display_name`
+ *   2. `custom_properties.original_filename`
+ *   3. cleaned `file_name`
+ *
+ * `alt_text` is NEVER used as a title — it's an accessibility field describing
+ * the image's content. Surfacing it as a tile/heading title teaches users to
+ * write worse alt text.
+ */
+export declare function getMediaDisplayName(item: Media): string;
+export declare function useMediaDisplayName(): {
+    getMediaDisplayName: typeof getMediaDisplayName;
+    cleanFileLikeName: typeof cleanFileLikeName;
+};

package/dist/composables/useMediaLibraryQuery.d.ts

@@ -1,11 +1,29 @@
-import { type Ref } from 'vue';
+import { type MaybeRefOrGetter, type Ref } from 'vue';
 import type { Media } from '../types/media';
 import type { MediaLibraryFilters, MediaLibraryHydratedRecord, MediaLibraryHttpClient, MediaLibraryPickerError, MediaLibraryView } from '../types/mediaLibraryPicker';
 interface UseMediaLibraryQueryOptions {
     httpClient: MediaLibraryHttpClient;
     view: Ref<MediaLibraryView>;
     filters: Ref<MediaLibraryFilters>;
-    perPage?: number;
+    /**
+     * Items per page. Accepts a plain number, a Ref, or a getter so the
+     * caller can flip page sizes at runtime (page-size selector). When
+     * the resolved value changes, callers should call `refresh()` /
+     * `loadInitial()` to re-fetch from the new size.
+     */
+    perPage?: MaybeRefOrGetter<number>;
+    /**
+     * Active page number for numbered (offset) pagination. When non-null,
+     * the composable runs in paginated mode: each load fetches an exact
+     * page slice from the server, items array is replaced (not appended),
+     * and `total` / `currentPage` / `totalPages` are populated. When null
+     * or omitted, the composable runs in cursor mode (the default).
+     */
+    page?: MaybeRefOrGetter<number | null>;
+}
+interface LoadAllOptions {
+    /** Hard cap on items loaded. Default: 5000. */
+    maxItems?: number;
 }
 export declare function useMediaLibraryQuery(options: UseMediaLibraryQueryOptions): {
     items: Ref<Media[]>;
@@ -16,8 +34,13 @@ export declare function useMediaLibraryQuery(options: UseMediaLibraryQueryOption
     loadingMore: Ref<boolean>;
     permissionDenied: Ref<boolean>;
     error: Ref<MediaLibraryPickerError | null>;
+    total: Ref<number | null>;
+    currentPage: Ref<number | null>;
+    totalPages: Ref<number | null>;
     loadInitial: () => Promise<void>;
     loadMore: () => Promise<void>;
+    loadAll: (options?: LoadAllOptions) => Promise<void>;
+    goToPage: (page: number) => Promise<void>;
     refresh: () => Promise<void>;
     hydrateSelection: (ids: string[]) => Promise<MediaLibraryHydratedRecord[]>;
     prepend: (media: Media) => void;

package/dist/composables/useMediaLibraryUploads.d.ts

@@ -0,0 +1,41 @@
+import type { Media } from '../types/media';
+import type { MediaLibraryHttpClient } from '../types/mediaLibraryPicker';
+export type MediaLibraryUploadStatus = 'queued' | 'uploading' | 'success' | 'error';
+export interface MediaLibraryOptimisticUpload {
+    cid: string;
+    fileName: string;
+    size: number;
+    status: MediaLibraryUploadStatus;
+    progress: number;
+    errorMessage?: string;
+    previewUrl?: string;
+}
+export interface UseMediaLibraryUploadsOptions {
+    httpClient: MediaLibraryHttpClient;
+    endpoint?: string;
+    onMediaUploaded?: (media: Media) => void | Promise<void>;
+}
+export declare function useMediaLibraryUploads(options: UseMediaLibraryUploadsOptions): {
+    uploads: import("vue").Ref<{
+        cid: string;
+        fileName: string;
+        size: number;
+        status: MediaLibraryUploadStatus;
+        progress: number;
+        errorMessage?: string | undefined;
+        previewUrl?: string | undefined;
+    }[], MediaLibraryOptimisticUpload[] | {
+        cid: string;
+        fileName: string;
+        size: number;
+        status: MediaLibraryUploadStatus;
+        progress: number;
+        errorMessage?: string | undefined;
+        previewUrl?: string | undefined;
+    }[]>;
+    hasActiveUploads: import("vue").ComputedRef<boolean>;
+    uploadFile: (file: File) => Promise<MediaLibraryOptimisticUpload>;
+    uploadFiles: (fileList: FileList | File[]) => Promise<MediaLibraryOptimisticUpload[]>;
+    dismiss: (cid: string) => void;
+    clear: () => void;
+};

package/dist/composables/useMediaSelection.d.ts

@@ -1,14 +1,41 @@
-import { type Ref } from 'vue';
+import { type MaybeRefOrGetter, type Ref } from 'vue';
 import type { Media } from '../types/media';
 export interface SelectionEvent {
     type: 'selection:changed';
     count: number;
     selectedIds: string[];
 }
-export declare function useMediaSelection(items: Ref<Media[]>): {
-    selectedIds: import("vue").ComputedRef<Set<string> & Omit<Set<string>, keyof Set<any>>>;
+export interface SelectAcrossAllPagesResult {
+    uuids: string[];
+    overCap: boolean;
+    totalMatching: number | null;
+}
+export interface MediaSelectionRecord {
+    uuid: string;
+    selectedAt: number;
+    page: number | null;
+}
+export interface UseMediaSelectionOptions {
+    scopeKey?: MaybeRefOrGetter<string>;
+    currentPage?: MaybeRefOrGetter<number | null>;
+    confirmScopeChange?: (payload: {
+        from: string;
+        to: string;
+        selectedCount: number;
+    }) => boolean | Promise<boolean>;
+    fetchMatchingUuids?: () => Promise<SelectAcrossAllPagesResult>;
+}
+export declare function useMediaSelection(items: Ref<Media[]>, options?: UseMediaSelectionOptions): {
+    selectedIds: import("vue").ComputedRef<Set<string>>;
+    selectedRecords: import("vue").ComputedRef<Map<string, MediaSelectionRecord>>;
     selectedItems: import("vue").ComputedRef<Media[]>;
     selectedCount: import("vue").ComputedRef<number>;
+    orderedIds: import("vue").ComputedRef<string[]>;
+    crossPageCount: import("vue").ComputedRef<number>;
+    selectedPages: import("vue").ComputedRef<Map<number, number>>;
+    overCap: import("vue").ComputedRef<boolean>;
+    totalMatching: import("vue").ComputedRef<number | null>;
+    activeScopeKey: import("vue").ComputedRef<string>;
     isAllSelected: import("vue").ComputedRef<boolean>;
     isSomeSelected: import("vue").ComputedRef<boolean>;
     lastSelectedId: import("vue").ComputedRef<string | null>;
@@ -19,7 +46,10 @@ export declare function useMediaSelection(items: Ref<Media[]>): {
     selectAll: () => void;
     clear: () => void;
     toggleAll: () => void;
-    rangeSelect: (targetUuid: string, event?: MouseEvent) => void;
+    rangeSelect: (targetUuid: string, event?: MouseEvent | PointerEvent) => void;
+    selectAcrossAllPages: () => Promise<SelectAcrossAllPagesResult>;
+    setScopeKey: (nextScopeKey: string) => Promise<boolean>;
+    canChangeScope: (nextScopeKey: string) => Promise<boolean>;
     selectNext: () => void;
     selectPrevious: () => void;
     handleKeydown: (event: KeyboardEvent) => void;

package/dist/composables/useMediaTrash.d.ts

@@ -36,12 +36,18 @@ export interface RestoreResult {
     duplicate_uuid?: string | null;
     message?: string;
 }
+export interface PurgeResult {
+    status: 'purging' | 'not_found' | 'not_trashed' | 'failed';
+    message?: string;
+}
 export interface UseMediaTrashOptions {
     httpClient: MediaLibraryHttpClient;
     /** Endpoint paths — overridable for apps with non-default routes (e.g., admin namespace). */
     listEndpoint?: string;
     /** Function building the restore endpoint URL. Default: `/v1/user/media/{uuid}/restore`. */
     buildRestoreEndpoint?: (uuid: string) => string;
+    /** Function building the permanent purge endpoint URL. Default: `/v1/user/media/{uuid}/purge`. */
+    buildPurgeEndpoint?: (uuid: string) => string;
     perPage?: number;
 }
 export interface UseMediaTrashReturn {
@@ -50,15 +56,19 @@ export interface UseMediaTrashReturn {
     currentPage: Ref<number>;
     isLoading: Ref<boolean>;
     isRestoring: Ref<boolean>;
+    isPurging: Ref<boolean>;
     error: Ref<Error | null>;
     fetch: (page?: number) => Promise<void>;
     restore: (uuid: string) => Promise<RestoreResult>;
+    purge: (uuid: string) => Promise<PurgeResult>;
     reset: () => void;
 }
 declare function buildDefaultRestoreEndpoint(uuid: string): string;
+declare function buildDefaultPurgeEndpoint(uuid: string): string;
 export declare function useMediaTrash(options: UseMediaTrashOptions): UseMediaTrashReturn;
 export declare const __testing__: {
     buildDefaultRestoreEndpoint: typeof buildDefaultRestoreEndpoint;
+    buildDefaultPurgeEndpoint: typeof buildDefaultPurgeEndpoint;
     DEFAULT_LIST_ENDPOINT: string;
 };
 export {};