@mapomodule/uikit 2.0.0-beta.17 → 2.0.0-beta.19
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/__tests__/MapoMediaEditor.component.test.d.ts +2 -0
- package/dist/__tests__/MapoMediaEditor.component.test.d.ts.map +1 -0
- package/dist/__tests__/MapoMediaFolderPicker.component.test.d.ts +2 -0
- package/dist/__tests__/MapoMediaFolderPicker.component.test.d.ts.map +1 -0
- package/dist/__tests__/MapoMediaFolders.component.test.d.ts +2 -0
- package/dist/__tests__/MapoMediaFolders.component.test.d.ts.map +1 -0
- package/dist/__tests__/MapoMediaGallery.component.test.d.ts +2 -0
- package/dist/__tests__/MapoMediaGallery.component.test.d.ts.map +1 -0
- package/dist/__tests__/MapoMediaUploadHandover.component.test.d.ts +2 -0
- package/dist/__tests__/MapoMediaUploadHandover.component.test.d.ts.map +1 -0
- package/dist/__tests__/MapoMenuManager.component.test.d.ts +2 -0
- package/dist/__tests__/MapoMenuManager.component.test.d.ts.map +1 -0
- package/dist/__tests__/mediaDrag.test.d.ts +2 -0
- package/dist/__tests__/mediaDrag.test.d.ts.map +1 -0
- package/dist/__tests__/mediaFolders.test.d.ts +2 -0
- package/dist/__tests__/mediaFolders.test.d.ts.map +1 -0
- package/dist/__tests__/mediaMetadata.test.d.ts +2 -0
- package/dist/__tests__/mediaMetadata.test.d.ts.map +1 -0
- package/dist/__tests__/mediaStore.test.d.ts +2 -0
- package/dist/__tests__/mediaStore.test.d.ts.map +1 -0
- package/dist/__tests__/mediaUrl.test.d.ts +2 -0
- package/dist/__tests__/mediaUrl.test.d.ts.map +1 -0
- package/dist/index.d.mts +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/module.d.mts +17 -0
- package/dist/module.d.ts +16 -0
- package/dist/module.d.ts.map +1 -1
- package/dist/module.json +1 -1
- package/dist/module.mjs +4 -0
- package/dist/runtime/adapters/defaultMediaAdapter.d.ts +1 -0
- package/dist/runtime/adapters/defaultMediaAdapter.d.ts.map +1 -1
- package/dist/runtime/adapters/defaultMediaAdapter.js +6 -1
- package/dist/runtime/components/MapoDetail.vue +9 -5
- package/dist/runtime/components/MapoDetail.vue.d.ts +3 -3
- package/dist/runtime/components/MapoDetail.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoDropArea.vue +17 -6
- package/dist/runtime/components/MapoDropArea.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoListQuickEdit.vue +7 -1
- package/dist/runtime/components/MapoListQuickEdit.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMediaEditor.vue +94 -38
- package/dist/runtime/components/MapoMediaEditor.vue.d.ts +4 -0
- package/dist/runtime/components/MapoMediaEditor.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMediaFolderPicker.vue +129 -0
- package/dist/runtime/components/MapoMediaFolderPicker.vue.d.ts +33 -0
- package/dist/runtime/components/MapoMediaFolderPicker.vue.d.ts.map +1 -0
- package/dist/runtime/components/MapoMediaFolders.vue +254 -72
- package/dist/runtime/components/MapoMediaFolders.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMediaGallery.vue +228 -143
- package/dist/runtime/components/MapoMediaGallery.vue.d.ts +5 -1
- package/dist/runtime/components/MapoMediaGallery.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMediaManager.vue +6 -2
- package/dist/runtime/components/MapoMediaManager.vue.d.ts +11 -2
- package/dist/runtime/components/MapoMediaManager.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMediaManagerDialog.vue.d.ts +1 -1
- package/dist/runtime/components/MapoMediaManagerDialog.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMediaPreview.vue +5 -3
- package/dist/runtime/components/MapoMediaPreview.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMediaUploader.vue +5 -1
- package/dist/runtime/components/MapoMediaUploader.vue.d.ts.map +1 -1
- package/dist/runtime/components/MapoMenuManager.vue +13 -5
- package/dist/runtime/components/MapoMenuManager.vue.d.ts.map +1 -1
- package/dist/runtime/stores/media.d.ts +43 -6
- package/dist/runtime/stores/media.d.ts.map +1 -1
- package/dist/runtime/stores/media.js +201 -16
- package/dist/runtime/types/media.d.ts +17 -2
- package/dist/runtime/types/media.d.ts.map +1 -1
- package/dist/runtime/utils/contentLanguages.d.ts +9 -0
- package/dist/runtime/utils/contentLanguages.d.ts.map +1 -0
- package/dist/runtime/utils/contentLanguages.js +8 -0
- package/dist/runtime/utils/langInfo.d.ts +13 -0
- package/dist/runtime/utils/langInfo.d.ts.map +1 -1
- package/dist/runtime/utils/langInfo.js +9 -0
- package/dist/runtime/utils/mediaDrag.d.ts +21 -0
- package/dist/runtime/utils/mediaDrag.d.ts.map +1 -0
- package/dist/runtime/utils/mediaDrag.js +11 -0
- package/dist/runtime/utils/mediaFolders.d.ts +65 -0
- package/dist/runtime/utils/mediaFolders.d.ts.map +1 -0
- package/dist/runtime/utils/mediaFolders.js +97 -0
- package/dist/runtime/utils/mediaMetadata.d.ts +39 -0
- package/dist/runtime/utils/mediaMetadata.d.ts.map +1 -0
- package/dist/runtime/utils/mediaMetadata.js +97 -0
- package/dist/runtime/utils/mediaUrl.d.ts +16 -0
- package/dist/runtime/utils/mediaUrl.d.ts.map +1 -0
- package/dist/runtime/utils/mediaUrl.js +12 -0
- package/package.json +3 -3
- package/src/__tests__/MapoDetail.component.test.ts +64 -1
- package/src/__tests__/MapoMediaEditor.component.test.ts +447 -0
- package/src/__tests__/MapoMediaFolderPicker.component.test.ts +220 -0
- package/src/__tests__/MapoMediaFolders.component.test.ts +519 -0
- package/src/__tests__/MapoMediaGallery.component.test.ts +211 -0
- package/src/__tests__/MapoMediaUploadHandover.component.test.ts +241 -0
- package/src/__tests__/MapoMenuManager.component.test.ts +175 -0
- package/src/__tests__/langInfo.test.ts +38 -1
- package/src/__tests__/mediaDrag.test.ts +42 -0
- package/src/__tests__/mediaFolders.test.ts +204 -0
- package/src/__tests__/mediaMetadata.test.ts +169 -0
- package/src/__tests__/mediaStore.test.ts +569 -0
- package/src/__tests__/mediaUrl.test.ts +44 -0
- package/src/index.ts +1 -0
- package/src/module.ts +25 -0
- package/src/runtime/adapters/defaultMediaAdapter.ts +11 -1
- package/src/runtime/components/MapoDetail.vue +21 -9
- package/src/runtime/components/MapoDropArea.vue +24 -6
- package/src/runtime/components/MapoListQuickEdit.vue +10 -1
- package/src/runtime/components/MapoMediaEditor.vue +131 -47
- package/src/runtime/components/MapoMediaFolderPicker.vue +176 -0
- package/src/runtime/components/MapoMediaFolders.vue +311 -72
- package/src/runtime/components/MapoMediaGallery.vue +263 -152
- package/src/runtime/components/MapoMediaManager.vue +16 -2
- package/src/runtime/components/MapoMediaPreview.vue +8 -3
- package/src/runtime/components/MapoMediaUploader.vue +8 -1
- package/src/runtime/components/MapoMenuManager.vue +24 -7
- package/src/runtime/stores/media.ts +335 -21
- package/src/runtime/types/media.ts +20 -2
- package/src/runtime/utils/contentLanguages.ts +18 -0
- package/src/runtime/utils/langInfo.ts +25 -0
- package/src/runtime/utils/mediaDrag.ts +29 -0
- package/src/runtime/utils/mediaFolders.ts +182 -0
- package/src/runtime/utils/mediaMetadata.ts +165 -0
- package/src/runtime/utils/mediaUrl.ts +30 -0
|
@@ -8,7 +8,20 @@ import { useMapoT } from "@mapomodule/i18n/runtime/composables/useMapoT";
|
|
|
8
8
|
import { applyMultipartPolicy } from "@mapomodule/core/runtime/api/multipart";
|
|
9
9
|
import { useNuxtApp, useRuntimeConfig } from "#app";
|
|
10
10
|
import { defaultMediaAdapter } from "../adapters/defaultMediaAdapter.js";
|
|
11
|
-
import {
|
|
11
|
+
import {
|
|
12
|
+
languagesFromMetadata,
|
|
13
|
+
pickLanguage,
|
|
14
|
+
restrictLanguages,
|
|
15
|
+
} from "../utils/langInfo.js";
|
|
16
|
+
import { useContentLanguages } from "../utils/contentLanguages.js";
|
|
17
|
+
import { buildUploadBody } from "../utils/mediaMetadata.js";
|
|
18
|
+
import {
|
|
19
|
+
canonicalFolder,
|
|
20
|
+
folderKey,
|
|
21
|
+
folderParentId,
|
|
22
|
+
folderPath,
|
|
23
|
+
} from "../utils/mediaFolders.js";
|
|
24
|
+
import type { MediaDrag } from "../utils/mediaDrag.js";
|
|
12
25
|
import type {
|
|
13
26
|
MediaItem,
|
|
14
27
|
MediaFolder,
|
|
@@ -62,6 +75,12 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
62
75
|
const medias = ref<MediaItem[]>([]);
|
|
63
76
|
const folders = ref<MediaFolder[]>([]);
|
|
64
77
|
const parentFolders = ref<MediaFolder[]>([]);
|
|
78
|
+
/**
|
|
79
|
+
* Subfolders of every folder seen so far, keyed by `folderKey` (the folder
|
|
80
|
+
* id, `"root"` for the top level). The folder tree reads it: a branch shows
|
|
81
|
+
* what is cached and loads the rest when it opens.
|
|
82
|
+
*/
|
|
83
|
+
const folderChildren = ref<Record<string, MediaFolder[]>>({});
|
|
65
84
|
const page = ref(1);
|
|
66
85
|
const pages = ref(1);
|
|
67
86
|
const mimeType = ref<string | null>(null);
|
|
@@ -76,6 +95,24 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
76
95
|
const selection = shallowRef<MediaItem | MediaItem[] | null>(null);
|
|
77
96
|
const editList = ref<number[]>([]);
|
|
78
97
|
const selectMode = ref<SelectMode>("none");
|
|
98
|
+
/**
|
|
99
|
+
* Files handed to the uploader from outside it (dropped on the gallery,
|
|
100
|
+
* picked with "Upload here"): it queues them, for the folder on screen,
|
|
101
|
+
* when it opens.
|
|
102
|
+
*/
|
|
103
|
+
const queuedUploads = shallowRef<File[]>([]);
|
|
104
|
+
/**
|
|
105
|
+
* Id of the folder `moveFolder` is moving, `null` when none: the folder
|
|
106
|
+
* tree disables its row actions meanwhile.
|
|
107
|
+
*/
|
|
108
|
+
const movingFolderId = ref<number | null>(null);
|
|
109
|
+
/**
|
|
110
|
+
* What is being dragged in the manager (gallery cards or a folder of the
|
|
111
|
+
* tree), set by the drag source while the drag lasts: drop targets read it
|
|
112
|
+
* to tell whether they take it, as a drag's data is not readable before
|
|
113
|
+
* the drop.
|
|
114
|
+
*/
|
|
115
|
+
const dragged = shallowRef<MediaDrag | null>(null);
|
|
79
116
|
|
|
80
117
|
// ─── Internal navigation context ────────────────────────────────────────
|
|
81
118
|
const _currentFolderId = ref<number | null>(null);
|
|
@@ -93,8 +130,34 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
93
130
|
// it a hardcoded list.
|
|
94
131
|
const languages = ref<string[]>([]);
|
|
95
132
|
let languagesPromise: Promise<void> | null = null;
|
|
133
|
+
// The host's own list (the manager's `languages` prop). Kept here, not in
|
|
134
|
+
// the editor, so the editor and the uploader always work on the same list.
|
|
135
|
+
const languageOverride = ref<string[]>([]);
|
|
136
|
+
|
|
137
|
+
// The app's `mapo.uikit.contentLanguages`, read once with the config.
|
|
138
|
+
const contentLanguages = useContentLanguages();
|
|
96
139
|
|
|
97
140
|
// ─── Getters ──────────────────────────────────────────────────────────────
|
|
141
|
+
/**
|
|
142
|
+
* Languages the metadata is edited and uploaded in: the host's list, else
|
|
143
|
+
* the endpoint's, narrowed to the app's content languages.
|
|
144
|
+
*/
|
|
145
|
+
const activeLanguages = computed(() =>
|
|
146
|
+
restrictLanguages(
|
|
147
|
+
languageOverride.value.length ? languageOverride.value : languages.value,
|
|
148
|
+
contentLanguages,
|
|
149
|
+
),
|
|
150
|
+
);
|
|
151
|
+
|
|
152
|
+
/**
|
|
153
|
+
* Language the editor opens on and uploads write into: the preferred one
|
|
154
|
+
* (`setLang`) when offered, else the first. `""` when media are not
|
|
155
|
+
* translated.
|
|
156
|
+
*/
|
|
157
|
+
const initialLanguage = computed(() =>
|
|
158
|
+
pickLanguage(activeLanguages.value, _currentLang.value),
|
|
159
|
+
);
|
|
160
|
+
|
|
98
161
|
const parentFolder = computed(
|
|
99
162
|
() => parentFolders.value[parentFolders.value.length - 1] ?? null,
|
|
100
163
|
);
|
|
@@ -150,14 +213,45 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
150
213
|
return languagesPromise;
|
|
151
214
|
}
|
|
152
215
|
|
|
216
|
+
/**
|
|
217
|
+
* An explorer response (the root or a folder) in the canonical shape: the
|
|
218
|
+
* adapter's `parseRootResponse`, then every folder with its parent as an id
|
|
219
|
+
* (`canonicalFolder`), whatever shape the adapter left it in.
|
|
220
|
+
*/
|
|
221
|
+
function parseExplorer(raw: unknown): MediaApiResponse {
|
|
222
|
+
const a = adapter();
|
|
223
|
+
const data = (a.parseRootResponse ?? defaultMediaAdapter.parseRootResponse)(
|
|
224
|
+
raw,
|
|
225
|
+
) as MediaApiResponse;
|
|
226
|
+
const parentFolder = data.parent_folder;
|
|
227
|
+
return {
|
|
228
|
+
...data,
|
|
229
|
+
folders: (data.folders ?? []).map(canonicalFolder),
|
|
230
|
+
parent_folder: parentFolder ? canonicalFolder(parentFolder) : null,
|
|
231
|
+
};
|
|
232
|
+
}
|
|
233
|
+
|
|
153
234
|
// ─── Breadcrumb maintenance ─────────────────────────────────────────────
|
|
154
|
-
// Driven by the response's `parent_folder` (matches the legacy contract)
|
|
155
|
-
//
|
|
235
|
+
// Driven by the response's `parent_folder` (matches the legacy contract).
|
|
236
|
+
// The folder tree lets the user jump to any folder, so the path is read from
|
|
237
|
+
// the folder cache the tree fills; only a folder the cache cannot place
|
|
238
|
+
// falls back to the legacy rule: push when entering, slice when going back.
|
|
156
239
|
function applyParentFolder(pf: MediaFolder | null): void {
|
|
157
|
-
|
|
240
|
+
// A folder without an id is the root too. Camomilla answers the root with
|
|
241
|
+
// an empty folder (`{ title: "", updir: null }`, DRF's serialization of no
|
|
242
|
+
// instance) rather than null; kept, it became a nameless breadcrumb and a
|
|
243
|
+
// "back to root" button on the root itself.
|
|
244
|
+
const isRoot = pf?.id == null;
|
|
245
|
+
if (isRoot) {
|
|
158
246
|
parentFolders.value = [];
|
|
159
247
|
return;
|
|
160
248
|
}
|
|
249
|
+
const cachedPath = folderPath(folderChildren.value, pf.id);
|
|
250
|
+
if (cachedPath) {
|
|
251
|
+
// The response's copy of the folder itself is the fresh one.
|
|
252
|
+
parentFolders.value = [...cachedPath.slice(0, -1), pf];
|
|
253
|
+
return;
|
|
254
|
+
}
|
|
161
255
|
const key = pf.path ?? pf.id;
|
|
162
256
|
const idx = parentFolders.value.findIndex((f) => (f.path ?? f.id) === key);
|
|
163
257
|
if (idx === -1) {
|
|
@@ -200,20 +294,45 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
200
294
|
? await crud.detail(folderId, { params: listParams })
|
|
201
295
|
: await crud.list(listParams as never);
|
|
202
296
|
|
|
203
|
-
const data = (
|
|
204
|
-
a.parseRootResponse ?? defaultMediaAdapter.parseRootResponse
|
|
205
|
-
)(raw) as MediaApiResponse;
|
|
297
|
+
const data = parseExplorer(raw);
|
|
206
298
|
|
|
207
299
|
medias.value = data.media.items;
|
|
208
300
|
page.value = data.media.paginator.page;
|
|
209
301
|
pages.value = data.media.paginator.pages;
|
|
210
302
|
folders.value = data.folders;
|
|
303
|
+
// A library-wide view (search, mime filter) lists no folder's children.
|
|
304
|
+
if (!all) setFolderChildren(folderId, data.folders);
|
|
211
305
|
applyParentFolder(data.parent_folder);
|
|
212
306
|
} finally {
|
|
213
307
|
loading.value = false;
|
|
214
308
|
}
|
|
215
309
|
}
|
|
216
310
|
|
|
311
|
+
function setFolderChildren(id: number | null, children: MediaFolder[]) {
|
|
312
|
+
folderChildren.value = {
|
|
313
|
+
...folderChildren.value,
|
|
314
|
+
[folderKey(id)]: children,
|
|
315
|
+
};
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
/**
|
|
319
|
+
* Load the subfolders of folder `id` (the root when `null`) into
|
|
320
|
+
* `folderChildren`, for the folder tree. It reads the same explorer
|
|
321
|
+
* endpoint as navigation, without changing the folder on screen.
|
|
322
|
+
*/
|
|
323
|
+
async function loadFolderChildren(id: number | null): Promise<void> {
|
|
324
|
+
const a = adapter();
|
|
325
|
+
const params = (a.buildListParams ?? defaultMediaAdapter.buildListParams)({
|
|
326
|
+
page: 1,
|
|
327
|
+
});
|
|
328
|
+
const crud = folderCrud();
|
|
329
|
+
const raw =
|
|
330
|
+
id != null
|
|
331
|
+
? await crud.detail(id, { params })
|
|
332
|
+
: await crud.list(params as never);
|
|
333
|
+
setFolderChildren(id, parseExplorer(raw).folders);
|
|
334
|
+
}
|
|
335
|
+
|
|
217
336
|
async function navigateToFolder(folder: MediaFolder | null): Promise<void> {
|
|
218
337
|
_currentFolderId.value = folder?.id ?? null;
|
|
219
338
|
_currentSearch.value = "";
|
|
@@ -242,14 +361,31 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
242
361
|
_currentLang.value = lang;
|
|
243
362
|
}
|
|
244
363
|
|
|
245
|
-
|
|
364
|
+
/** Impose the metadata languages instead of reading them from the endpoint; empty clears it. */
|
|
365
|
+
function setLanguages(langs: string[] | undefined): void {
|
|
366
|
+
languageOverride.value = langs ?? [];
|
|
367
|
+
}
|
|
368
|
+
|
|
369
|
+
/**
|
|
370
|
+
* Save the metadata of `media`. With `previous`, the media as it was when
|
|
371
|
+
* editing started, the default adapter sends only what changed; when nothing
|
|
372
|
+
* did, no request is made.
|
|
373
|
+
*/
|
|
374
|
+
async function updateMedia(
|
|
375
|
+
media: MediaItem,
|
|
376
|
+
previous?: MediaItem,
|
|
377
|
+
): Promise<MediaItem> {
|
|
246
378
|
const a = adapter();
|
|
247
379
|
const payload = (
|
|
248
380
|
a.buildMediaPatchPayload ?? defaultMediaAdapter.buildMediaPatchPayload
|
|
249
|
-
)(media);
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
if (
|
|
381
|
+
)(media, previous);
|
|
382
|
+
let updated = media;
|
|
383
|
+
const hasChanges = Object.keys(payload).length > 0;
|
|
384
|
+
if (hasChanges) {
|
|
385
|
+
updated = await mediaCrud().partialUpdate(media.id, payload as never);
|
|
386
|
+
// Keep the open editor in sync with the server response (legacy behavior).
|
|
387
|
+
if (editMedia.value?.id === media.id) editMedia.value = updated;
|
|
388
|
+
}
|
|
253
389
|
useSnackStore().show(useMapoT()("mapo.mediaManager.fileInfo"), "success");
|
|
254
390
|
await getRoot();
|
|
255
391
|
return updated;
|
|
@@ -274,18 +410,150 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
274
410
|
return updated;
|
|
275
411
|
}
|
|
276
412
|
|
|
413
|
+
/**
|
|
414
|
+
* Move media to folder `folderId` (the root when `null`), one PATCH each
|
|
415
|
+
* through the adapter. Reports how many moved and how many did not, drops
|
|
416
|
+
* the moved ones from the bulk selection and refreshes the folder on
|
|
417
|
+
* screen. Returns the ids that moved.
|
|
418
|
+
*/
|
|
419
|
+
async function moveMedia(
|
|
420
|
+
ids: number[],
|
|
421
|
+
folderId: number | null,
|
|
422
|
+
): Promise<number[]> {
|
|
423
|
+
const a = adapter();
|
|
424
|
+
const payload = (
|
|
425
|
+
a.buildMoveMediaPayload ?? defaultMediaAdapter.buildMoveMediaPayload
|
|
426
|
+
)(folderId);
|
|
427
|
+
const results = await Promise.allSettled(
|
|
428
|
+
ids.map((id) => mediaCrud().partialUpdate(id, payload as never)),
|
|
429
|
+
);
|
|
430
|
+
const moved = ids.filter((_, i) => results[i]?.status === "fulfilled");
|
|
431
|
+
const notMoved = ids.length - moved.length;
|
|
432
|
+
|
|
433
|
+
const t = useMapoT();
|
|
434
|
+
const snack = useSnackStore();
|
|
435
|
+
if (moved.length) {
|
|
436
|
+
snack.show(
|
|
437
|
+
t("mapo.mediaMove.moved", { number: moved.length }),
|
|
438
|
+
"success",
|
|
439
|
+
);
|
|
440
|
+
}
|
|
441
|
+
if (notMoved) {
|
|
442
|
+
snack.show(t("mapo.mediaMove.failed", { number: notMoved }), "error");
|
|
443
|
+
}
|
|
444
|
+
editList.value = editList.value.filter((id) => !moved.includes(id));
|
|
445
|
+
await getRoot();
|
|
446
|
+
return moved;
|
|
447
|
+
}
|
|
448
|
+
|
|
277
449
|
async function updateOrCreateFolder(
|
|
278
450
|
folder: Partial<MediaFolder>,
|
|
279
451
|
): Promise<void> {
|
|
280
452
|
const a = adapter();
|
|
453
|
+
const target = { parent: _currentFolderId.value, ...folder };
|
|
281
454
|
const payload = (
|
|
282
455
|
a.buildFolderPayload ?? defaultMediaAdapter.buildFolderPayload
|
|
283
|
-
)(
|
|
284
|
-
parent: _currentFolderId.value,
|
|
285
|
-
...folder,
|
|
286
|
-
});
|
|
456
|
+
)(target);
|
|
287
457
|
await folderCrud().updateOrCreate(payload as never);
|
|
288
458
|
await getRoot();
|
|
459
|
+
// The tree can rename a folder outside the one on screen: refresh the
|
|
460
|
+
// branch it lives in too.
|
|
461
|
+
const parentId = target.parent ?? null;
|
|
462
|
+
const isElsewhere = parentId !== _currentFolderId.value;
|
|
463
|
+
if (isElsewhere) await loadFolderChildren(parentId);
|
|
464
|
+
}
|
|
465
|
+
|
|
466
|
+
/**
|
|
467
|
+
* Move `folder` into folder `parentId` (the root when `null`), saving it
|
|
468
|
+
* with the adapter's folder payload (Camomilla: `updir`). A folder cannot go
|
|
469
|
+
* inside itself or one of its subfolders, and Camomilla does not check it
|
|
470
|
+
* (it would recurse): the picker never offers them, and this refuses them
|
|
471
|
+
* as far as the folder cache knows the tree. One move runs at a time
|
|
472
|
+
* (`movingFolderId`); another one asked meanwhile is refused. Refreshes the
|
|
473
|
+
* branch the folder left, the one it joined and the folder on screen, whose
|
|
474
|
+
* path may run through it. Returns whether it moved; rejects only when the
|
|
475
|
+
* final refresh of the folder on screen fails.
|
|
476
|
+
*/
|
|
477
|
+
async function moveFolder(
|
|
478
|
+
folder: MediaFolder,
|
|
479
|
+
parentId: number | null,
|
|
480
|
+
): Promise<boolean> {
|
|
481
|
+
// One move at a time: until the tree reloads, it still shows the folder
|
|
482
|
+
// in its old place, and a second move picked from it could close a cycle.
|
|
483
|
+
const isBusy = movingFolderId.value !== null;
|
|
484
|
+
if (isBusy) return false;
|
|
485
|
+
const fromId = folderParentId(folderChildren.value, folder);
|
|
486
|
+
const staysPut = fromId === parentId;
|
|
487
|
+
if (staysPut) return false;
|
|
488
|
+
|
|
489
|
+
const t = useMapoT();
|
|
490
|
+
const snack = useSnackStore();
|
|
491
|
+
const notMoved = () =>
|
|
492
|
+
snack.show(
|
|
493
|
+
t("mapo.mediaMove.folderFailed", { name: folder.name }),
|
|
494
|
+
"error",
|
|
495
|
+
);
|
|
496
|
+
// The picker already hides these; callers outside it are checked here.
|
|
497
|
+
const isSelf = parentId === folder.id;
|
|
498
|
+
const targetPath =
|
|
499
|
+
parentId == null
|
|
500
|
+
? []
|
|
501
|
+
: (folderPath(folderChildren.value, parentId) ?? []);
|
|
502
|
+
const isInside = targetPath.some((f) => f.id === folder.id);
|
|
503
|
+
if (isSelf || isInside) {
|
|
504
|
+
notMoved();
|
|
505
|
+
return false;
|
|
506
|
+
}
|
|
507
|
+
|
|
508
|
+
movingFolderId.value = folder.id;
|
|
509
|
+
try {
|
|
510
|
+
const a = adapter();
|
|
511
|
+
const payload = (
|
|
512
|
+
a.buildFolderPayload ?? defaultMediaAdapter.buildFolderPayload
|
|
513
|
+
)({ ...folder, parent: parentId });
|
|
514
|
+
try {
|
|
515
|
+
await folderCrud().updateOrCreate(payload as never);
|
|
516
|
+
} catch {
|
|
517
|
+
notMoved();
|
|
518
|
+
return false;
|
|
519
|
+
}
|
|
520
|
+
snack.show(
|
|
521
|
+
t("mapo.mediaMove.folderMoved", { name: folder.name }),
|
|
522
|
+
"success",
|
|
523
|
+
);
|
|
524
|
+
// Out of every cached branch at once, whatever the reloads do: a stale
|
|
525
|
+
// branch must not offer the folder, or its subfolders, as a destination.
|
|
526
|
+
detachFolder(folder.id);
|
|
527
|
+
// The folder on screen reloads with `getRoot` below.
|
|
528
|
+
const isOnScreen = (id: number | null) =>
|
|
529
|
+
!_currentAll.value && id === _currentFolderId.value;
|
|
530
|
+
const [, joined] = await Promise.allSettled([
|
|
531
|
+
isOnScreen(fromId) ? null : loadFolderChildren(fromId),
|
|
532
|
+
isOnScreen(parentId) ? null : loadFolderChildren(parentId),
|
|
533
|
+
]);
|
|
534
|
+
// Unknown again rather than wrong: the branch reloads when opened.
|
|
535
|
+
if (joined.status === "rejected") forgetFolderChildren(parentId);
|
|
536
|
+
await getRoot();
|
|
537
|
+
return true;
|
|
538
|
+
} finally {
|
|
539
|
+
movingFolderId.value = null;
|
|
540
|
+
}
|
|
541
|
+
}
|
|
542
|
+
|
|
543
|
+
/** Remove folder `id` from every cached branch. */
|
|
544
|
+
function detachFolder(id: number): void {
|
|
545
|
+
const next: Record<string, MediaFolder[]> = {};
|
|
546
|
+
for (const [key, children] of Object.entries(folderChildren.value)) {
|
|
547
|
+
next[key] = children.filter((child) => child.id !== id);
|
|
548
|
+
}
|
|
549
|
+
folderChildren.value = next;
|
|
550
|
+
}
|
|
551
|
+
|
|
552
|
+
/** Drop the cached subfolders of folder `id`: the tree loads them again. */
|
|
553
|
+
function forgetFolderChildren(id: number | null): void {
|
|
554
|
+
const rest = { ...folderChildren.value };
|
|
555
|
+
delete rest[folderKey(id)];
|
|
556
|
+
folderChildren.value = rest;
|
|
289
557
|
}
|
|
290
558
|
|
|
291
559
|
async function deleteFolder(folder: MediaFolder): Promise<void> {
|
|
@@ -297,8 +565,23 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
297
565
|
dangerous: true,
|
|
298
566
|
});
|
|
299
567
|
if (!confirmed) return;
|
|
568
|
+
const parentId = folderParentId(folderChildren.value, folder);
|
|
300
569
|
await folderCrud().delete(folder.id);
|
|
570
|
+
|
|
571
|
+
const remaining = { ...folderChildren.value };
|
|
572
|
+
delete remaining[folderKey(folder.id)];
|
|
573
|
+
folderChildren.value = remaining;
|
|
574
|
+
// The folder on screen, or one above it, is gone: show its parent.
|
|
575
|
+
const isOnPath = parentFolders.value.some((f) => f.id === folder.id);
|
|
576
|
+
if (isOnPath) {
|
|
577
|
+
await navigateToFolder(
|
|
578
|
+
parentId == null ? null : { id: parentId, name: "" },
|
|
579
|
+
);
|
|
580
|
+
return;
|
|
581
|
+
}
|
|
301
582
|
await getRoot();
|
|
583
|
+
const isElsewhere = parentId !== _currentFolderId.value;
|
|
584
|
+
if (isElsewhere) await loadFolderChildren(parentId);
|
|
302
585
|
}
|
|
303
586
|
|
|
304
587
|
async function deleteMedia(media: MediaItem): Promise<void> {
|
|
@@ -389,15 +672,14 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
389
672
|
payload: MediaUploadPayload,
|
|
390
673
|
onProgress?: (percent: number) => void,
|
|
391
674
|
): Promise<MediaItem> {
|
|
675
|
+
// Translated media take their metadata as a translation, and only the
|
|
676
|
+
// endpoint's OPTIONS says whether they are: wait for that answer.
|
|
677
|
+
await deriveLanguages();
|
|
678
|
+
const body = buildUploadBody(payload, initialLanguage.value || undefined);
|
|
392
679
|
// Build the body through the same multipart pipeline every other write uses
|
|
393
680
|
// (`data` JSON envelope + files at their dot-path). Hand-rolling a flat
|
|
394
681
|
// FormData here made uploads the only write that spoke a different wire
|
|
395
682
|
// format, which backends parsing the envelope reject.
|
|
396
|
-
const body: Record<string, unknown> = { file: payload.file };
|
|
397
|
-
if (payload.title) body.title = payload.title;
|
|
398
|
-
if (payload.alt_text) body.alt_text = payload.alt_text;
|
|
399
|
-
if (payload.description) body.description = payload.description;
|
|
400
|
-
if (payload.folder != null) body.folder = payload.folder;
|
|
401
683
|
const formData = applyMultipartPolicy(body, "force") as FormData;
|
|
402
684
|
|
|
403
685
|
// ofetch has no upload-progress hook, so uploads go through XHR.
|
|
@@ -433,6 +715,18 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
433
715
|
});
|
|
434
716
|
}
|
|
435
717
|
|
|
718
|
+
/** Hand files to the uploader, which queues them when it opens. */
|
|
719
|
+
function queueUploads(files: File[]): void {
|
|
720
|
+
queuedUploads.value = [...queuedUploads.value, ...files];
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
/** The files handed to the uploader, emptying the hand-over. */
|
|
724
|
+
function takeQueuedUploads(): File[] {
|
|
725
|
+
const files = queuedUploads.value;
|
|
726
|
+
queuedUploads.value = [];
|
|
727
|
+
return files;
|
|
728
|
+
}
|
|
729
|
+
|
|
436
730
|
function setMimeType(mime: string | null): void {
|
|
437
731
|
// A locked picker can narrow the filter but never widen it past the lock.
|
|
438
732
|
mimeType.value = mime ?? lockedMime.value;
|
|
@@ -447,6 +741,7 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
447
741
|
medias.value = [];
|
|
448
742
|
folders.value = [];
|
|
449
743
|
parentFolders.value = [];
|
|
744
|
+
folderChildren.value = {};
|
|
450
745
|
page.value = 1;
|
|
451
746
|
pages.value = 1;
|
|
452
747
|
mimeType.value = null;
|
|
@@ -456,9 +751,16 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
456
751
|
selection.value = null;
|
|
457
752
|
editList.value = [];
|
|
458
753
|
selectMode.value = "none";
|
|
754
|
+
queuedUploads.value = [];
|
|
755
|
+
dragged.value = null;
|
|
756
|
+
// `movingFolderId` is left to the move still running, if any: a manager
|
|
757
|
+
// opened meanwhile must not offer a second one before it lands.
|
|
459
758
|
_currentFolderId.value = null;
|
|
460
759
|
_currentSearch.value = "";
|
|
461
760
|
_currentAll.value = false;
|
|
761
|
+
// Both come from the manager's props: the next manager sets its own.
|
|
762
|
+
_currentLang.value = undefined;
|
|
763
|
+
languageOverride.value = [];
|
|
462
764
|
}
|
|
463
765
|
|
|
464
766
|
return {
|
|
@@ -466,6 +768,7 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
466
768
|
medias,
|
|
467
769
|
folders,
|
|
468
770
|
parentFolders,
|
|
771
|
+
folderChildren,
|
|
469
772
|
page,
|
|
470
773
|
pages,
|
|
471
774
|
mimeType,
|
|
@@ -475,8 +778,13 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
475
778
|
selection,
|
|
476
779
|
editList,
|
|
477
780
|
selectMode,
|
|
781
|
+
queuedUploads,
|
|
782
|
+
movingFolderId,
|
|
783
|
+
dragged,
|
|
478
784
|
languages,
|
|
479
785
|
// getters
|
|
786
|
+
activeLanguages,
|
|
787
|
+
initialLanguage,
|
|
480
788
|
parentFolder,
|
|
481
789
|
editListSet,
|
|
482
790
|
editListState,
|
|
@@ -484,12 +792,16 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
484
792
|
getRoot,
|
|
485
793
|
deriveLanguages,
|
|
486
794
|
navigateToFolder,
|
|
795
|
+
loadFolderChildren,
|
|
487
796
|
openEditor,
|
|
488
797
|
closeEditor,
|
|
489
798
|
setLang,
|
|
799
|
+
setLanguages,
|
|
490
800
|
updateMedia,
|
|
491
801
|
replaceFile,
|
|
802
|
+
moveMedia,
|
|
492
803
|
updateOrCreateFolder,
|
|
804
|
+
moveFolder,
|
|
493
805
|
deleteFolder,
|
|
494
806
|
deleteMedia,
|
|
495
807
|
select,
|
|
@@ -499,6 +811,8 @@ export const useMediaStore = defineStore("mapo-media", () => {
|
|
|
499
811
|
editSelectAll,
|
|
500
812
|
deleteSelected,
|
|
501
813
|
uploadMedia,
|
|
814
|
+
queueUploads,
|
|
815
|
+
takeQueuedUploads,
|
|
502
816
|
setMimeType,
|
|
503
817
|
lockMimeType,
|
|
504
818
|
reset,
|
|
@@ -15,6 +15,10 @@ import type { MediaItem } from "@mapomodule/form/types";
|
|
|
15
15
|
export interface MediaFolder {
|
|
16
16
|
id: number;
|
|
17
17
|
name: string;
|
|
18
|
+
/**
|
|
19
|
+
* Id of the parent folder, `null` at the top level. The store reads a
|
|
20
|
+
* parent given as an object (Camomilla's nested `updir`) by its `id`.
|
|
21
|
+
*/
|
|
18
22
|
parent?: number | null;
|
|
19
23
|
/**
|
|
20
24
|
* Materialized path of the folder (e.g. "root/images/hero").
|
|
@@ -111,9 +115,23 @@ export interface MediaAdapter {
|
|
|
111
115
|
buildFolderPayload?(folder: Partial<MediaFolder>): Record<string, unknown>;
|
|
112
116
|
/**
|
|
113
117
|
* Build the PATCH payload for a media metadata update.
|
|
114
|
-
*
|
|
118
|
+
*
|
|
119
|
+
* `previous` is the media as it was when editing started; the editor always
|
|
120
|
+
* passes it. Default: with `previous`, only the fields that changed, with
|
|
121
|
+
* `translations` narrowed to the changed languages and fields; without it,
|
|
122
|
+
* `{ title, alt_text, description, translations }`. An empty object skips
|
|
123
|
+
* the request.
|
|
124
|
+
*/
|
|
125
|
+
buildMediaPatchPayload?(
|
|
126
|
+
media: MediaItem,
|
|
127
|
+
previous?: MediaItem,
|
|
128
|
+
): Record<string, unknown>;
|
|
129
|
+
/**
|
|
130
|
+
* Build the PATCH payload that moves a media to folder `folderId` (`null`
|
|
131
|
+
* is the root). Default: `{ folder: folderId }`, which Camomilla takes as
|
|
132
|
+
* it is.
|
|
115
133
|
*/
|
|
116
|
-
|
|
134
|
+
buildMoveMediaPayload?(folderId: number | null): Record<string, unknown>;
|
|
117
135
|
/**
|
|
118
136
|
* Build the multipart PATCH payload for a file replacement.
|
|
119
137
|
* @example
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import { useRuntimeConfig } from "#app";
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* The app's `mapo.uikit.contentLanguages`: the content languages editors may
|
|
5
|
+
* switch between, in order. Empty when the app sets none, which restricts
|
|
6
|
+
* nothing. Narrow a list with `restrictLanguages` from `./langInfo`.
|
|
7
|
+
*
|
|
8
|
+
* Kept apart from `langInfo.ts`, whose helpers stay free of Nuxt imports.
|
|
9
|
+
*/
|
|
10
|
+
export function useContentLanguages(): string[] {
|
|
11
|
+
const runtimeConfig = useRuntimeConfig();
|
|
12
|
+
const uikit = (runtimeConfig.public.mapoUikit ?? {}) as {
|
|
13
|
+
contentLanguages?: unknown;
|
|
14
|
+
};
|
|
15
|
+
const configured = uikit.contentLanguages;
|
|
16
|
+
if (!Array.isArray(configured)) return [];
|
|
17
|
+
return configured.filter((code): code is string => typeof code === "string");
|
|
18
|
+
}
|
|
@@ -36,3 +36,28 @@ export function languagesFromMetadata(metadata: unknown): string[] {
|
|
|
36
36
|
(code): code is string => typeof code === "string",
|
|
37
37
|
);
|
|
38
38
|
}
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* `languages` narrowed to `allowed` (the app's `mapo.uikit.contentLanguages`),
|
|
42
|
+
* in `allowed`'s order, so its first language is the one editing starts on.
|
|
43
|
+
* An empty `allowed` restricts nothing. It never adds a language the list does
|
|
44
|
+
* not offer: the backend would drop whatever is typed for it.
|
|
45
|
+
*/
|
|
46
|
+
export function restrictLanguages(
|
|
47
|
+
languages: string[],
|
|
48
|
+
allowed: string[],
|
|
49
|
+
): string[] {
|
|
50
|
+
if (!allowed.length) return languages;
|
|
51
|
+
return allowed.filter((lang) => languages.includes(lang));
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
/**
|
|
55
|
+
* The language to start from: `preferred` when the list offers it, else the
|
|
56
|
+
* first one. Returns `""` for an empty list, which callers read as "this
|
|
57
|
+
* model is not translated".
|
|
58
|
+
*/
|
|
59
|
+
export function pickLanguage(languages: string[], preferred?: string): string {
|
|
60
|
+
if (!preferred) return languages[0] ?? "";
|
|
61
|
+
const isOffered = languages.includes(preferred);
|
|
62
|
+
return isOffered ? preferred : (languages[0] ?? "");
|
|
63
|
+
}
|
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
import type { MediaFolder } from "../types/media.js";
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* Data type of every drag started inside the media manager: a gallery card,
|
|
5
|
+
* the bulk selection, a folder of the tree. Drop zones for files from the
|
|
6
|
+
* computer ignore it, since Chrome reports an image dragged from the page as
|
|
7
|
+
* "Files" too.
|
|
8
|
+
*/
|
|
9
|
+
export const MEDIA_DRAG_TYPE = "application/x-mapo-media-drag";
|
|
10
|
+
|
|
11
|
+
/** What is being dragged inside the media manager. */
|
|
12
|
+
export type MediaDrag =
|
|
13
|
+
| { kind: "media"; ids: number[] }
|
|
14
|
+
| { kind: "folder"; folder: MediaFolder };
|
|
15
|
+
|
|
16
|
+
/** Whether `event` drags something from inside the media manager. */
|
|
17
|
+
export function isMediaDrag(event: DragEvent): boolean {
|
|
18
|
+
const types = Array.from(event.dataTransfer?.types ?? []);
|
|
19
|
+
return types.includes(MEDIA_DRAG_TYPE);
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
/** Starts dragging `drag`: the data type that marks it, and a move. */
|
|
23
|
+
export function startMediaDrag(event: DragEvent, drag: MediaDrag): void {
|
|
24
|
+
const transfer = event.dataTransfer;
|
|
25
|
+
if (!transfer) return;
|
|
26
|
+
// Firefox starts a drag only once some data is set.
|
|
27
|
+
transfer.setData(MEDIA_DRAG_TYPE, JSON.stringify(drag));
|
|
28
|
+
transfer.effectAllowed = "move";
|
|
29
|
+
}
|