@fluid-app/portal-sdk 0.1.135 → 0.1.136

package/dist/{src-BbjxT3sc.mjs → portal-tenant-product-media-adapter-Co9Kw-US.mjs}

@@ -88,9 +88,24 @@ const shareablesKeys = {
 //#endregion
 //#region ../../shareables/core/src/api-context.tsx
 const ShareablesApiContext = createContext(null);
-function ShareablesApiProvider({ api, children }) {
+function ShareablesApiProvider({ media, playlists, fileResources, share, productMedia, children }) {
+	const value = useMemo(() => ({
+		media,
+		playlists,
+		fileResources,
+		share,
+		productMedia: productMedia ?? { getProductMedia: () => {
+			throw new Error("ProductMediaApi not provided to ShareablesApiProvider");
+		} }
+	}), [
+		media,
+		playlists,
+		fileResources,
+		share,
+		productMedia
+	]);
 	return /* @__PURE__ */ jsx(ShareablesApiContext.Provider, {
-		value: api,
+		value,
 		children
 	});
 }
@@ -8895,6 +8910,967 @@ function ProductsApp({ countryCode, companyLogoUrl, fetchProducts, fetchProduct,
 	});
 }
 //#endregion
-export { ShareablesCoreProvider as a, ShareablesApiProvider as i, ShareablesApp as n, ShareablesUIProvider as r, ProductsApp as t };
+//#region ../../api-clients/portal-tenant-content/src/namespaces/portal_tenant_content.ts
+/**
+* List media (own uploads and company media)
+* Returns a paginated list of the member's own uploads and company-owned media.
+*
+* @param client - Fetch client instance
+* @param [params] - params
+*/
+async function media_list(client, params) {
+	return client.get(`/api/content/media`, params);
+}
+/**
+* Create a new media item
+* Creates a new media item record.
+*
+* @param client - Fetch client instance
+* @param body - body
+*/
+async function media_create(client, body) {
+	return client.post(`/api/content/media`, body);
+}
+/**
+* Get a specific media item
+* Returns a single media item by ID.
+*
+* @param client - Fetch client instance
+* @param id - id
+*/
+async function media_show(client, id) {
+	return client.get(`/api/content/media/${id}`);
+}
+/**
+* Update a media item (own uploads only)
+* Updates a media item's title or description.
+*
+* @param client - Fetch client instance
+* @param id - id
+* @param body - body
+*/
+async function media_update(client, id, body) {
+	return client.patch(`/api/content/media/${id}`, body);
+}
+/**
+* Delete a media item (own uploads only)
+* Removes a media item.
+*
+* @param client - Fetch client instance
+* @param id - id
+*/
+async function media_destroy(client, id) {
+	return client.delete(`/api/content/media/${id}`);
+}
+/**
+* List playlists with cursor pagination
+* Returns a paginated list of playlists.
+*
+* @param client - Fetch client instance
+* @param [params] - params
+*/
+async function playlists_list(client, params) {
+	return client.get(`/api/content/playlists`, params);
+}
+/**
+* Create a new playlist
+* Creates a new playlist.
+*
+* @param client - Fetch client instance
+* @param body - body
+*/
+async function playlists_create(client, body) {
+	return client.post(`/api/content/playlists`, body);
+}
+/**
+* Get a specific playlist
+* Returns a single playlist by ID.
+*
+* @param client - Fetch client instance
+* @param id - id
+*/
+async function playlists_show(client, id) {
+	return client.get(`/api/content/playlists/${id}`);
+}
+/**
+* Update a playlist
+* Updates a playlist's title or metadata.
+*
+* @param client - Fetch client instance
+* @param id - id
+* @param body - body
+*/
+async function playlists_update(client, id, body) {
+	return client.patch(`/api/content/playlists/${id}`, body);
+}
+/**
+* Delete a playlist
+* Removes a playlist.
+*
+* @param client - Fetch client instance
+* @param id - id
+*/
+async function playlists_destroy(client, id) {
+	return client.delete(`/api/content/playlists/${id}`);
+}
+/**
+* List items in a playlist
+* Returns a paginated list of items in a playlist.
+*
+* @param client - Fetch client instance
+* @param playlist_id - playlist_id
+* @param [params] - params
+*/
+async function playlists_items_list(client, playlist_id, params) {
+	return client.get(`/api/content/playlists/${playlist_id}/items`, params);
+}
+/**
+* Add an item to a playlist
+* Adds a media item to a playlist.
+*
+* @param client - Fetch client instance
+* @param playlist_id - playlist_id
+* @param body - body
+*/
+async function playlists_items_add(client, playlist_id, body) {
+	return client.post(`/api/content/playlists/${playlist_id}/items`, body);
+}
+/**
+* Remove an item from a playlist
+* Removes a single item from a playlist.
+*
+* @param client - Fetch client instance
+* @param playlist_id - playlist_id
+* @param id - id
+*/
+async function playlists_items_remove(client, playlist_id, id) {
+	return client.delete(`/api/content/playlists/${playlist_id}/items/${id}`);
+}
+/**
+* List share links for the current user
+* Returns a paginated list of share links.
+*
+* @param client - Fetch client instance
+* @param [params] - params
+*/
+async function shares_list(client, params) {
+	return client.get(`/api/shares`, params);
+}
+/**
+* Create a share link
+* Creates a new share link for content.
+*
+* @param client - Fetch client instance
+* @param body - body
+*/
+async function shares_create(client, body) {
+	return client.post(`/api/shares`, body);
+}
+/**
+* List DAM assets
+* Returns a paginated list of DAM assets for the company.
+*
+* @param client - Fetch client instance
+* @param [params] - params
+*/
+async function dam_assets_list(client, params) {
+	return client.get(`/api/content/dam/assets`, params);
+}
+/**
+* Create a DAM asset
+* Creates a new DAM asset. Supports two modes:
+1. **JSON placeholder** — send `application/json` with `asset[name]` to
+create a placeholder record for later file upload.
+
+2. **File upload** — send `multipart/form-data` with `asset[file]`,
+`asset[name]`, and optionally `asset[description]` and `asset[tags]`
+to upload a file and create the full asset with variants.
+*
+* @param client - Fetch client instance
+* @param body - body
+*/
+async function dam_assets_create(client, body) {
+	return client.post(`/api/content/dam/assets`, body);
+}
+/**
+* List paths for a DAM asset
+* Returns a paginated list of path aliases for a DAM asset.
+*
+* @param client - Fetch client instance
+* @param asset_code - asset_code
+* @param [params] - params
+*/
+async function dam_asset_paths_list(client, asset_code, params) {
+	return client.get(`/api/content/dam/assets/${asset_code}/paths`, params);
+}
+/**
+* Create a path alias for a DAM asset
+* Creates a new path alias for an existing DAM asset.
+*
+* @param client - Fetch client instance
+* @param asset_code - asset_code
+* @param body - body
+*/
+async function dam_asset_paths_create(client, asset_code, body) {
+	return client.post(`/api/content/dam/assets/${asset_code}/paths`, body);
+}
+/**
+* Query DAM assets using tree paths and tags
+* Searches and retrieves DAM assets using tree path pattern matching, tag-based variant filtering, wildcard name matching, and partial search. Supports cursor pagination for large result sets.
+*
+* @param client - Fetch client instance
+* @param body - body
+*/
+async function dam_query(client, body) {
+	return client.post(`/api/content/dam/query`, body);
+}
+/**
+* Delete a DAM asset
+* Permanently destroys a DAM asset, including its ImageKit storage, variants, and database records.
+*
+* @param client - Fetch client instance
+* @param code - code
+*/
+async function dam_assets_destroy(client, code) {
+	return client.delete(`/api/content/dam/assets/${code}`);
+}
+/**
+* Discard (soft-delete) a DAM asset
+* Soft-deletes a DAM asset. Used to discard an in-progress upload without permanently removing the record.
+*
+* @param client - Fetch client instance
+* @param code - code
+*/
+async function dam_assets_discard(client, code) {
+	return client.patch(`/api/content/dam/assets/${code}/discard`);
+}
+//#endregion
+//#region ../../shareables/api-client/src/portal-tenant-media-adapter.ts
+/**
+* Maps a BFF media object to the port's Media shape, providing defaults
+* for optional fields returned by the generated client.
+*/
+function mapMedia(raw) {
+	return {
+		id: raw.id ?? 0,
+		title: raw.title ?? "",
+		description: raw.description ?? null,
+		media_type: raw.media_type ?? "",
+		url: raw.url ?? null,
+		thumbnail_url: raw.thumbnail_url ?? null,
+		owner_type: raw.owner_type ?? "",
+		created_at: raw.created_at ?? "",
+		updated_at: raw.updated_at ?? ""
+	};
+}
+/**
+* Maps the BFF meta envelope to the port's ApiMeta shape.
+*/
+function mapMeta$3(raw) {
+	return {
+		request_id: raw?.request_id ?? null,
+		timestamp: raw?.timestamp ?? "",
+		pagination: raw?.pagination ? {
+			cursor: raw.pagination.cursor ?? null,
+			limit: raw.pagination.limit,
+			next_cursor: raw.pagination.next_cursor ?? null,
+			prev_cursor: raw.pagination.prev_cursor ?? null
+		} : void 0
+	};
+}
+/**
+* Creates a ContentMediaApi adapter backed by the portal-tenant content BFF.
+*
+* Maps the generated portal-tenant-content namespace functions to the abstract
+* ContentMediaApi port, closing over the FetchClient so consumers don't need
+* to pass it per-call.
+*/
+function createPortalTenantMediaAdapter(client) {
+	return {
+		listMedia: async (params) => {
+			const response = await media_list(client, {
+				"page[cursor]": params?.cursor,
+				"page[limit]": params?.limit,
+				media_type: params?.media_type,
+				"filter[title]": params?.["filter[title]"],
+				sort: params?.sort
+			});
+			return {
+				media: (response.media ?? []).map(mapMedia),
+				meta: mapMeta$3(response.meta)
+			};
+		},
+		createMedia: async (body) => {
+			const response = await media_create(client, { media: body });
+			return {
+				media: mapMedia(response.media ?? {}),
+				meta: mapMeta$3(response.meta)
+			};
+		},
+		getMedia: async (id) => {
+			const response = await media_show(client, id);
+			return {
+				media: mapMedia(response.media ?? {}),
+				meta: mapMeta$3(response.meta)
+			};
+		},
+		updateMedia: async (id, body) => {
+			const response = await media_update(client, id, { media: body });
+			return {
+				media: mapMedia(response.media ?? {}),
+				meta: mapMeta$3(response.meta)
+			};
+		},
+		deleteMedia: async (id) => {
+			const response = await media_destroy(client, id);
+			return {
+				media: { id: response.media?.id ?? 0 },
+				meta: mapMeta$3(response.meta)
+			};
+		}
+	};
+}
+function mediaKindFromType$1(mediaType) {
+	if (mediaType === "video") return "video";
+	if (mediaType === "image") return "image";
+	if (mediaType === "document" || mediaType === "pdf") return "pdf";
+	return null;
+}
+function toBffMediumResponse(bff) {
+	const kind = mediaKindFromType$1(bff.media_type);
+	const isVideo = bff.media_type === "video";
+	const isPdf = bff.media_type === "pdf" || bff.media_type === "document";
+	return {
+		id: bff.id,
+		user_id: null,
+		media_type: bff.media_type,
+		media_format: bff.media_type,
+		image_url: !isVideo && !isPdf ? bff.url ?? bff.thumbnail_url ?? null : bff.thumbnail_url ?? null,
+		video_url: isVideo ? bff.url ?? null : null,
+		pdf_url: isPdf ? bff.url ?? null : null,
+		title: bff.title,
+		description: {
+			id: null,
+			name: null,
+			body: bff.description ?? null,
+			record_type: null,
+			record_id: null,
+			created_at: bff.created_at ?? null,
+			updated_at: bff.updated_at ?? null,
+			locale: null
+		},
+		stripped: bff.description ?? null,
+		kind,
+		active: true,
+		visibility: null,
+		share_link: null,
+		views: 0,
+		leads: 0,
+		watch: null,
+		video_status: null,
+		duration: null,
+		cta_url: null,
+		cta_button_text: null,
+		cta_enabled: false,
+		cta_action_type: null,
+		video_shopping_enabled: false,
+		prompts_enabled: false,
+		ranks: [],
+		preview_link: null,
+		attached_shareables: [],
+		created_at: bff.created_at
+	};
+}
+/**
+* Creates a ShareablesApi["media"]-compatible adapter backed by the
+* portal-tenant content BFF. Includes cursor-to-page-number caching
+* for bridging the legacy UI's page-number pagination.
+*/
+function createPortalTenantMediaShareablesAdapter(client) {
+	const portAdapter = createPortalTenantMediaAdapter(client);
+	const cursorByPage = /* @__PURE__ */ new Map();
+	let lastFilterKey = "";
+	return {
+		getMedia: async (options) => {
+			const pageNumber = options?.page ?? 1;
+			const filterKey = `${options?.search_query ?? ""}|${options?.sorted_by ?? ""}|${options?.media_type ?? options?.with_type ?? ""}`;
+			if (filterKey !== lastFilterKey) {
+				cursorByPage.clear();
+				lastFilterKey = filterKey;
+			}
+			const cursor = pageNumber > 1 ? cursorByPage.get(pageNumber) : void 0;
+			const rawSort = options?.sorted_by;
+			let bffSort;
+			if (rawSort === "title_asc") bffSort = "title_asc";
+			else if (rawSort === "title_desc") bffSort = "title_desc";
+			const response = await portAdapter.listMedia({
+				cursor,
+				limit: options?.per_page,
+				media_type: options?.media_type ?? options?.with_type,
+				"filter[title]": options?.search_query,
+				sort: bffSort
+			});
+			const nextCursor = response.meta.pagination?.next_cursor;
+			if (nextCursor) cursorByPage.set(pageNumber + 1, nextCursor);
+			const transformedItems = response.media.map(toBffMediumResponse);
+			return {
+				data: transformedItems,
+				status: "success",
+				media: transformedItems,
+				meta: {
+					total_count: transformedItems.length,
+					current: pageNumber,
+					per_page: options?.per_page ?? 24,
+					pages: nextCursor ? pageNumber + 1 : pageNumber,
+					next: nextCursor ? pageNumber + 1 : null,
+					previous: pageNumber > 1 ? pageNumber - 1 : null
+				}
+			};
+		},
+		getMediaById: async (id) => {
+			const medium = toBffMediumResponse((await portAdapter.getMedia(id)).media);
+			return {
+				data: medium,
+				status: "success",
+				media: medium
+			};
+		},
+		createMedia: async (mediaData) => {
+			return toBffMediumResponse((await portAdapter.createMedia({
+				title: mediaData.title ?? "",
+				description: mediaData.description,
+				media_type: mediaData.media_type ?? "image",
+				url: mediaData.image_url ?? mediaData.video_url ?? mediaData.pdf_url ?? void 0
+			})).media);
+		},
+		updateMedia: async (id, mediaData) => {
+			return toBffMediumResponse((await portAdapter.updateMedia(id, {
+				title: mediaData.title,
+				description: mediaData.description
+			})).media);
+		},
+		deleteMedia: async (id) => {
+			await portAdapter.deleteMedia(id);
+			return { success: true };
+		}
+	};
+}
+//#endregion
+//#region ../../shareables/api-client/src/portal-tenant-playlists-adapter.ts
+/**
+* Maps a BFF playlist object to the port's Playlist shape.
+*/
+function mapPlaylist(raw) {
+	return {
+		id: raw.id ?? 0,
+		title: raw.title ?? "",
+		description: raw.description ?? null,
+		items_count: raw.items_count ?? 0,
+		user_id: raw.user_id,
+		is_favorited: raw.is_favorited,
+		image_url: raw.image_url ?? null,
+		created_at: raw.created_at ?? "",
+		updated_at: raw.updated_at ?? ""
+	};
+}
+/**
+* Maps a BFF playlist item to the port's PlaylistItem shape.
+*/
+function mapPlaylistItem(raw) {
+	return {
+		id: raw.id ?? 0,
+		media_id: raw.media_id ?? 0,
+		position: raw.position ?? null,
+		title: raw.title,
+		image_url: raw.image_url ?? null,
+		media_type: raw.media_type,
+		video_url: raw.video_url ?? null,
+		duration: raw.duration ?? null,
+		created_at: raw.created_at ?? ""
+	};
+}
+/**
+* Maps the BFF meta envelope to the port's ApiMeta shape.
+*/
+function mapMeta$2(raw) {
+	return {
+		request_id: raw?.request_id ?? null,
+		timestamp: raw?.timestamp ?? "",
+		pagination: raw?.pagination ? {
+			cursor: raw.pagination.cursor ?? null,
+			limit: raw.pagination.limit,
+			next_cursor: raw.pagination.next_cursor ?? null,
+			prev_cursor: raw.pagination.prev_cursor ?? null
+		} : void 0
+	};
+}
+/**
+* Creates a ContentPlaylistsApi adapter backed by the portal-tenant content BFF.
+*
+* Maps the generated portal-tenant-content namespace functions to the abstract
+* ContentPlaylistsApi port, closing over the FetchClient so consumers don't
+* need to pass it per-call.
+*/
+function createPortalTenantPlaylistsAdapter(client) {
+	return {
+		listPlaylists: async (params) => {
+			const response = await playlists_list(client, {
+				"page[cursor]": params?.cursor,
+				"page[limit]": params?.limit,
+				"filter[title]": params?.["filter[title]"],
+				sort: params?.sort
+			});
+			return {
+				playlists: (response.playlists ?? []).map(mapPlaylist),
+				meta: mapMeta$2(response.meta)
+			};
+		},
+		createPlaylist: async (body) => {
+			const response = await playlists_create(client, { playlist: body });
+			return {
+				playlist: mapPlaylist(response.playlist ?? {}),
+				meta: mapMeta$2(response.meta)
+			};
+		},
+		getPlaylist: async (id) => {
+			const response = await playlists_show(client, id);
+			return {
+				playlist: mapPlaylist(response.playlist ?? {}),
+				meta: mapMeta$2(response.meta)
+			};
+		},
+		updatePlaylist: async (id, body) => {
+			const response = await playlists_update(client, id, { playlist: body });
+			return {
+				playlist: mapPlaylist(response.playlist ?? {}),
+				meta: mapMeta$2(response.meta)
+			};
+		},
+		deletePlaylist: async (id) => {
+			const response = await playlists_destroy(client, id);
+			return {
+				playlist: { id: response.playlist?.id ?? 0 },
+				meta: mapMeta$2(response.meta)
+			};
+		},
+		listPlaylistItems: async (playlistId, params) => {
+			const response = await playlists_items_list(client, playlistId, {
+				"page[cursor]": params?.cursor,
+				"page[limit]": params?.limit
+			});
+			return {
+				playlist_items: (response.playlist_items ?? []).map(mapPlaylistItem),
+				meta: mapMeta$2(response.meta)
+			};
+		},
+		addPlaylistItem: async (playlistId, body) => {
+			const response = await playlists_items_add(client, playlistId, { item: body });
+			return {
+				playlist_item: mapPlaylistItem(response.playlist_item ?? {}),
+				meta: mapMeta$2(response.meta)
+			};
+		},
+		removePlaylistItem: async (playlistId, itemId) => {
+			const response = await playlists_items_remove(client, playlistId, itemId);
+			return {
+				playlist_item: { id: response.playlist_item?.id ?? 0 },
+				meta: mapMeta$2(response.meta)
+			};
+		}
+	};
+}
+function mediaKindFromType(mediaType) {
+	if (mediaType === "video") return "video";
+	if (mediaType === "image") return "image";
+	if (mediaType === "document" || mediaType === "pdf") return "pdf";
+	return null;
+}
+function toBffPlaylist(bff, items) {
+	return {
+		id: bff.id,
+		title: bff.title,
+		description: bff.description ?? null,
+		image_url: bff.image_url ?? null,
+		slug: null,
+		active: true,
+		user_id: bff.user_id ?? null,
+		is_favorited: bff.is_favorited ?? false,
+		items: items ?? [],
+		items_count: bff.items_count
+	};
+}
+/**
+* Creates a ShareablesApi["playlists"]-compatible adapter backed by the
+* portal-tenant content BFF. Fetches playlist + items in parallel for
+* detail views and maps enriched flat fields onto playlist items.
+*/
+function createPortalTenantPlaylistsShareablesAdapter(client) {
+	const portAdapter = createPortalTenantPlaylistsAdapter(client);
+	return {
+		getPlaylists: async (options) => {
+			const rawSort = options?.sort;
+			let bffSort;
+			if (rawSort === "title_asc" || rawSort === "title") bffSort = "title_asc";
+			else if (rawSort === "title_desc" || rawSort === "-title") bffSort = "title_desc";
+			else if (rawSort === "created_at_asc" || rawSort === "created_at") bffSort = "created_at_asc";
+			else if (rawSort === "created_at_desc" || rawSort === "-created_at") bffSort = "created_at_desc";
+			const response = await portAdapter.listPlaylists({
+				cursor: options?.["page[cursor]"],
+				limit: options?.["page[limit]"],
+				"filter[title]": options?.["filter[title]"],
+				sort: bffSort
+			});
+			return {
+				playlists: response.playlists.map((p) => toBffPlaylist(p)),
+				meta: {
+					request_id: response.meta.request_id ?? "",
+					timestamp: response.meta.timestamp ?? "",
+					pagination: {
+						cursor: response.meta.pagination?.cursor ?? null,
+						limit: response.meta.pagination?.limit ?? 12,
+						prev_cursor: response.meta.pagination?.prev_cursor ?? null,
+						next_cursor: response.meta.pagination?.next_cursor ?? null,
+						total_count: 0,
+						total_pages: 0
+					}
+				}
+			};
+		},
+		getPlaylistById: async (id) => {
+			const response = await portAdapter.getPlaylist(id);
+			const allItems = [];
+			let cursor;
+			const MAX_PAGES = 50;
+			for (let i = 0; i < MAX_PAGES; i++) {
+				const page = await portAdapter.listPlaylistItems(id, {
+					cursor,
+					limit: 100
+				});
+				allItems.push(...page.playlist_items);
+				cursor = page.meta.pagination?.next_cursor ?? void 0;
+				if (!cursor) break;
+			}
+			const items = allItems.map((item) => ({
+				id: item.id,
+				order: item.position ?? void 0,
+				relateable_type: "Medium",
+				relateable: { id: item.media_id },
+				title: item.title ?? "Untitled",
+				image_url: item.image_url ?? null,
+				kind: mediaKindFromType(item.media_type ?? ""),
+				video_url: item.video_url ?? null,
+				duration: item.duration ?? null,
+				media_format: item.media_type ?? null
+			}));
+			return {
+				playlist: toBffPlaylist(response.playlist, items),
+				meta: {
+					request_id: response.meta.request_id ?? "",
+					timestamp: response.meta.timestamp ?? ""
+				}
+			};
+		},
+		createPlaylist: async (data) => {
+			const response = await portAdapter.createPlaylist({
+				title: data.playlist.title,
+				description: data.playlist.description
+			});
+			return {
+				playlist: toBffPlaylist(response.playlist),
+				meta: {
+					request_id: response.meta.request_id ?? "",
+					timestamp: response.meta.timestamp ?? ""
+				}
+			};
+		},
+		updatePlaylist: async (id, data) => {
+			const response = await portAdapter.updatePlaylist(id, {
+				title: data.playlist.title,
+				description: data.playlist.description
+			});
+			return {
+				playlist: toBffPlaylist(response.playlist),
+				meta: {
+					request_id: response.meta.request_id ?? "",
+					timestamp: response.meta.timestamp ?? ""
+				}
+			};
+		},
+		addItemToPlaylist: async (id, data) => {
+			await Promise.all(data.items.map((item) => portAdapter.addPlaylistItem(id, {
+				media_id: item.relateable_id,
+				position: typeof item.order === "number" ? item.order : Number(item.order)
+			})));
+			return toBffPlaylist((await portAdapter.getPlaylist(id)).playlist);
+		},
+		removeItemsFromPlaylist: async (playlistId, data) => {
+			await Promise.all(data.item_ids.map((itemId) => portAdapter.removePlaylistItem(playlistId, itemId)));
+			return toBffPlaylist((await portAdapter.getPlaylist(playlistId)).playlist);
+		}
+	};
+}
+//#endregion
+//#region ../../shareables/api-client/src/portal-tenant-dam-assets-adapter.ts
+/**
+* Maps a BFF DAM asset to the port's DamAsset shape.
+*/
+function mapDamAsset(raw) {
+	return {
+		id: raw.id ?? 0,
+		code: raw.code ?? "",
+		name: raw.name ?? "",
+		description: raw.description ?? null,
+		category: raw.category ?? null,
+		company: raw.company ?? null,
+		default_variant_id: raw.default_variant_id ?? null,
+		default_variant_url: raw.default_variant_url ?? null,
+		canonical_path: raw.canonical_path ?? null,
+		created_at: raw.created_at ?? "",
+		updated_at: raw.updated_at ?? ""
+	};
+}
+/**
+* Maps a BFF DAM asset path to the port's DamAssetPath shape.
+*/
+function mapDamAssetPath(raw) {
+	return {
+		id: raw.id ?? 0,
+		asset_code: raw.asset_code ?? "",
+		path: raw.path ?? "",
+		created_at: raw.created_at ?? ""
+	};
+}
+/**
+* Maps the BFF meta envelope to the port's ApiMeta shape.
+*/
+function mapMeta$1(raw) {
+	return {
+		request_id: raw?.request_id ?? null,
+		timestamp: raw?.timestamp ?? "",
+		pagination: raw?.pagination ? {
+			cursor: raw.pagination.cursor ?? null,
+			limit: raw.pagination.limit,
+			next_cursor: raw.pagination.next_cursor ?? null,
+			prev_cursor: raw.pagination.prev_cursor ?? null
+		} : void 0
+	};
+}
+/**
+* Creates a ContentDamAssetsApi adapter backed by the portal-tenant content BFF.
+*
+* Maps the generated portal-tenant-content namespace functions to the abstract
+* ContentDamAssetsApi port, closing over the FetchClient so consumers don't
+* need to pass it per-call.
+*/
+function createPortalTenantDamAssetsAdapter(client) {
+	return {
+		listAssets: async (params) => {
+			const response = await dam_assets_list(client, {
+				"page[cursor]": params?.cursor,
+				"page[limit]": params?.limit
+			});
+			return {
+				assets: (response.assets ?? []).map(mapDamAsset),
+				meta: mapMeta$1(response.meta)
+			};
+		},
+		createAsset: async (body) => {
+			const response = await dam_assets_create(client, { asset: body });
+			return {
+				asset: mapDamAsset(response.asset ?? {}),
+				meta: mapMeta$1(response.meta)
+			};
+		},
+		listAssetPaths: async (assetCode, params) => {
+			const response = await dam_asset_paths_list(client, assetCode, {
+				"page[cursor]": params?.cursor,
+				"page[limit]": params?.limit
+			});
+			return {
+				asset_paths: (response.asset_paths ?? []).map(mapDamAssetPath),
+				meta: mapMeta$1(response.meta)
+			};
+		},
+		createAssetPath: async (assetCode, body) => {
+			const response = await dam_asset_paths_create(client, assetCode, { asset_path: body });
+			return {
+				asset_path: mapDamAssetPath(response.asset_path ?? {}),
+				meta: mapMeta$1(response.meta)
+			};
+		}
+	};
+}
+/**
+* Creates a ShareablesApi["fileResources"]-compatible adapter backed by the
+* portal-tenant content BFF. Maps DamAsset to FileResource shape and
+* includes cursor-to-page-number caching for legacy UI pagination.
+*/
+function createPortalTenantFilesShareablesAdapter(client) {
+	const portAdapter = createPortalTenantDamAssetsAdapter(client);
+	const cursorByPage = /* @__PURE__ */ new Map();
+	return { getFileResources: async (params) => {
+		const pageNumber = params?.pageParam ? Number(params.pageParam) : 1;
+		const pageSize = params?.pageSize ? Number(params.pageSize) : 25;
+		const cursor = pageNumber > 1 ? cursorByPage.get(pageNumber) : void 0;
+		const response = await portAdapter.listAssets({
+			cursor,
+			limit: pageSize
+		});
+		const nextCursor = response.meta.pagination?.next_cursor;
+		if (nextCursor) cursorByPage.set(pageNumber + 1, nextCursor);
+		const fileResources = response.assets.map((asset) => ({
+			id: asset.id,
+			alt_text: asset.name,
+			url: asset.default_variant_url ?? "",
+			filename: asset.name,
+			content_type: "application/octet-stream",
+			content_size: 0,
+			handle: asset.code,
+			dam_asset_code: asset.code,
+			preview_image_url: asset.default_variant_url ?? "",
+			created_at: asset.created_at,
+			updated_at: asset.updated_at ?? "",
+			relateable_type: null,
+			relateable_id: null,
+			content: null
+		}));
+		const hasNextPage = !!nextCursor;
+		return {
+			file_resources: fileResources,
+			meta: {
+				total_count: fileResources.length,
+				per_page: pageSize,
+				current_page: pageNumber,
+				total_pages: hasNextPage ? pageNumber + 1 : pageNumber
+			}
+		};
+	} };
+}
+//#endregion
+//#region ../../shareables/api-client/src/portal-tenant-shares-adapter.ts
+/**
+* Narrows an unknown string to a valid ShareableType at runtime.
+*/
+function isShareableType(value) {
+	return value === "media" || value === "product" || value === "library" || value === "page";
+}
+/**
+* Maps a BFF share to the port's Share shape.
+*/
+function mapShare(raw) {
+	return {
+		id: raw.id ?? 0,
+		url: raw.url ?? "",
+		shareable_type: isShareableType(raw.shareable_type) ? raw.shareable_type : "media",
+		shareable_id: raw.shareable_id ?? 0,
+		created_at: raw.created_at ?? ""
+	};
+}
+/**
+* Maps the BFF meta envelope to the port's ApiMeta shape.
+*/
+function mapMeta(raw) {
+	return {
+		request_id: raw?.request_id ?? null,
+		timestamp: raw?.timestamp ?? "",
+		pagination: raw?.pagination ? {
+			cursor: raw.pagination.cursor ?? null,
+			limit: raw.pagination.limit,
+			next_cursor: raw.pagination.next_cursor ?? null,
+			prev_cursor: raw.pagination.prev_cursor ?? null
+		} : void 0
+	};
+}
+/**
+* Creates a ContentSharesApi adapter backed by the portal-tenant content BFF.
+*
+* Maps the generated portal-tenant-content namespace functions to the abstract
+* ContentSharesApi port, closing over the FetchClient so consumers don't need
+* to pass it per-call.
+*/
+function createPortalTenantSharesAdapter(client) {
+	return {
+		listShares: async (params) => {
+			const response = await shares_list(client, {
+				"page[cursor]": params?.cursor,
+				"page[limit]": params?.limit
+			});
+			return {
+				shares: (response.shares ?? []).map(mapShare),
+				meta: mapMeta(response.meta)
+			};
+		},
+		createShare: async (body) => {
+			const response = await shares_create(client, { share: body });
+			return {
+				share: mapShare(response.share ?? {}),
+				meta: mapMeta(response.meta)
+			};
+		}
+	};
+}
+/**
+* Maps legacy Rails model names (used by the UI) to BFF shareable_type values.
+*/
+const SHAREABLE_TYPE_MAP = {
+	Medium: "media",
+	media: "media",
+	Product: "product",
+	product: "product",
+	Library: "library",
+	library: "library",
+	Page: "page",
+	page: "page"
+};
+/**
+* Creates a ShareablesApi["share"]-compatible adapter backed by the
+* portal-tenant content BFF. Maps legacy model names to BFF shareable types.
+*/
+function createPortalTenantSharesShareablesAdapter(client) {
+	const portAdapter = createPortalTenantSharesAdapter(client);
+	return { createShareLink: async (input) => {
+		if (!input.relateableId) throw new Error("Cannot create share link without a relateableId");
+		const shareableType = SHAREABLE_TYPE_MAP[input.relateableType];
+		if (!shareableType) throw new Error(`Unknown shareable type: "${input.relateableType}"`);
+		return (await portAdapter.createShare({
+			shareable_type: shareableType,
+			shareable_id: input.relateableId
+		})).share.url;
+	} };
+}
+//#endregion
+//#region ../../shareables/api-client/src/portal-tenant-product-media-adapter.ts
+function mapProductMedia(raw) {
+	const isVideo = raw.media_type === "video";
+	const isPdf = raw.media_type === "pdf" || raw.media_type === "document";
+	return {
+		id: raw.id ?? 0,
+		slug: null,
+		title: raw.title ?? "",
+		kind: isVideo ? "video" : isPdf ? "pdf" : "image",
+		media_type: raw.media_type ?? "image",
+		media_format: raw.media_type ?? "image",
+		image_url: !isVideo && !isPdf ? raw.url ?? null : null,
+		video_url: isVideo ? raw.url ?? null : null,
+		pdf_url: isPdf ? raw.url ?? null : null,
+		powerpoint_url: null,
+		duration: 0,
+		description: null,
+		subtitles: {},
+		comments_count: 0
+	};
+}
+/**
+* Creates a ShareablesApi["productMedia"]-compatible adapter that bridges
+* the products BFF into the shareables domain. Takes any object satisfying
+* ProductMediaSource (e.g. PortalProductsApi from products-core).
+*/
+function createPortalTenantProductMediaShareablesAdapter(source) {
+	return { getProductMedia: async (productId) => {
+		return { media: ((await source.getProductMedia(productId)).media ?? []).map(mapProductMedia) };
+	} };
+}
+//#endregion
+export { createPortalTenantPlaylistsShareablesAdapter as a, dam_assets_destroy as c, ProductsApp as d, ShareablesApp as f, ShareablesCoreProvider as h, createPortalTenantPlaylistsAdapter as i, dam_assets_discard as l, ShareablesApiProvider as m, createPortalTenantSharesShareablesAdapter as n, createPortalTenantMediaShareablesAdapter as o, ShareablesUIProvider as p, createPortalTenantFilesShareablesAdapter as r, dam_asset_paths_create as s, createPortalTenantProductMediaShareablesAdapter as t, dam_query as u };
 
-//# sourceMappingURL=src-BbjxT3sc.mjs.map
+//# sourceMappingURL=portal-tenant-product-media-adapter-Co9Kw-US.mjs.map