@fluid-app/portal-sdk 0.1.131 → 0.1.133

package/dist/ShareablesScreen-B6tMQzuX.mjs

@@ -0,0 +1,1314 @@
+import { et as USER_TYPES, u as usePortalTenantClient } from "./FluidProvider-BUdNsR8f.mjs";
+import { t as useFluidAuth } from "./use-fluid-auth-DrPeCmW-.mjs";
+import { n as useCurrentUser } from "./use-current-user-BP_GJuQe.mjs";
+import { n as useAppNavigation } from "./AppNavigationContext-Du3Qq0yc.mjs";
+import { i as useSdkClient } from "./use-account-clients-BjK5QVYl.mjs";
+import { a as ShareablesApiProvider, i as ShareablesUIProvider, n as ShareablesApp, o as ShareablesCoreProvider, r as getFileMimeType } from "./src-DcIV4Mpe.mjs";
+import { t as usePortalProductsClient } from "./use-portal-products-client-dV5jIXpp.mjs";
+import { useCallback, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+import { z } from "zod";
+//#region src/hooks/use-user-type.ts
+/**
+* Convenience hook for user-type checks in the portal SDK.
+*/
+function useUserType() {
+	const { user } = useFluidAuth();
+	return useMemo(() => {
+		const userType = user?.user_type ?? null;
+		return {
+			userType,
+			isCustomer: userType === USER_TYPES.customer,
+			isRep: userType === USER_TYPES.rep,
+			isAdmin: userType === USER_TYPES.admin || userType === USER_TYPES.root_admin
+		};
+	}, [user?.user_type]);
+}
+//#endregion
+//#region ../../file-picker/core/src/schemas/dam.ts
+const damVariantSchema = z.object({
+	id: z.string(),
+	url: z.string().nullable(),
+	file_name: z.string(),
+	mime_type: z.string(),
+	content: z.any().nullable(),
+	created_at: z.string(),
+	updated_at: z.string(),
+	default: z.boolean(),
+	is_original: z.boolean(),
+	is_text: z.boolean(),
+	media_type: z.string(),
+	processing_status: z.string(),
+	tags: z.array(z.string())
+});
+const damAssetSchema = z.object({
+	id: z.number(),
+	canonical_path: z.string(),
+	category: z.string(),
+	code: z.string(),
+	company: z.string(),
+	created_at: z.string(),
+	default_variant_id: z.string(),
+	default_variant_url: z.string().optional(),
+	description: z.string(),
+	name: z.string(),
+	updated_at: z.string(),
+	variants: z.array(damVariantSchema).optional()
+});
+const damTreeFolderNodeSchema = z.object({
+	asset_code: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+	name: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+	category: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+	variants: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional()
+}).passthrough();
+const damTreeSchema = z.record(z.string(), z.union([
+	z.lazy(() => damTreeSchema),
+	damAssetSchema,
+	damTreeFolderNodeSchema
+]));
+const damQueryResponseSchema = z.object({
+	path: z.string(),
+	tree: damTreeSchema,
+	meta: z.object({ next_cursor: z.string().optional() }).optional()
+});
+z.object({ asset: z.object({
+	file: z.any(),
+	name: z.string(),
+	description: z.string().optional(),
+	tags: z.string().optional()
+}) });
+const damAssetCreateResponseSchema = z.object({
+	asset: damAssetSchema,
+	meta: z.object({
+		request_id: z.string(),
+		timestamp: z.string()
+	})
+});
+z.object({
+	placeholder_asset: z.object({
+		mime_type: z.string(),
+		name: z.string().optional(),
+		description: z.string().optional()
+	}),
+	skip_autotagging: z.boolean().optional()
+});
+z.object({
+	asset: z.object({
+		file: z.any(),
+		name: z.string(),
+		description: z.string().optional(),
+		tags: z.string().optional()
+	}).optional(),
+	text_asset: z.object({
+		file_name: z.string(),
+		mime_type: z.string(),
+		text: z.string(),
+		name: z.string().optional(),
+		description: z.string().optional(),
+		tags: z.string().optional()
+	}).optional(),
+	placeholder_asset: z.object({
+		mime_type: z.string(),
+		name: z.string().optional(),
+		description: z.string().optional()
+	}).optional(),
+	skip_autotagging: z.boolean().optional()
+});
+const damAssetPathCreateResponseSchema = z.object({
+	asset: z.object({
+		id: z.number(),
+		canonical_path: z.string(),
+		name: z.string()
+	}),
+	meta: z.object({
+		request_id: z.string(),
+		timestamp: z.string()
+	})
+});
+//#endregion
+//#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 placeholder
+* Creates a new DAM asset placeholder record with a canonical path.
+*
+* @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);
+}
+//#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 ?? "",
+		content_type: raw.content_type ?? null,
+		byte_size: raw.byte_size ?? null,
+		url: raw.url ?? 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.url ?? "",
+			filename: asset.name,
+			content_type: asset.content_type ?? "application/octet-stream",
+			content_size: asset.byte_size ?? 0,
+			handle: asset.code,
+			dam_asset_code: asset.code,
+			preview_image_url: asset.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 ../../file-picker/api-client/src/client.ts
+function createFilePickerClient(config) {
+	return {
+		fetchClient: config.fetchClient,
+		uploadStrategy: config.uploadStrategy,
+		unsplashAccessKey: config.unsplashAccessKey,
+		proxyEndpoint: config.proxyEndpoint ?? "/api/proxy-url"
+	};
+}
+//#endregion
+//#region ../../file-picker/api-client/src/api/dam-assets.ts
+/**
+* Create a DAM asset. Text files use FormData upload; non-text files
+* delegate to the provided uploadStrategy (e.g. ImageKit).
+* If no uploadStrategy is provided, all files use FormData upload.
+*/
+async function createDamAsset(fetchClient, params, uploadStrategy) {
+	const mimeType = getFileMimeType(params.file);
+	if (mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || params.file.name.endsWith(".txt") || params.file.name.endsWith(".json") || params.file.name.endsWith(".xml") || params.file.name.endsWith(".csv")) return createDamAssetViaFormData(fetchClient, params);
+	if (uploadStrategy) return uploadStrategy.uploadFile(params);
+	return createDamAssetViaFormData(fetchClient, params);
+}
+async function createDamAssetViaFormData(fetchClient, params) {
+	const formData = new FormData();
+	formData.append("asset[file]", params.file);
+	formData.append("asset[name]", params.name);
+	if (params.description) formData.append("asset[description]", params.description);
+	if (params.tags && params.tags.length > 0) formData.append("asset[tags]", params.tags.join(","));
+	const response = await fetchClient.requestWithFormData("/dam/assets", formData, { method: "POST" });
+	return damAssetCreateResponseSchema.parse(response);
+}
+async function createDamAssetPathForAssets(fetchClient, { asset_paths, code }) {
+	const response = await fetchClient.post(`/dam/assets/${code}/asset_paths`, { asset_paths });
+	return damAssetPathCreateResponseSchema.parse(response);
+}
+//#endregion
+//#region ../../file-picker/api-client/src/api/dam-query.ts
+async function queryDamAssets(fetchClient, params) {
+	const response = await fetchClient.post("/dam/query", params);
+	return damQueryResponseSchema.parse(response);
+}
+async function deleteDamAsset(fetchClient, code) {
+	return fetchClient.delete(`/dam/assets/${code}`);
+}
+async function discardDamAsset(fetchClient, code) {
+	return fetchClient.patch(`/dam/assets/${code}/discard`);
+}
+//#endregion
+//#region ../../file-picker/api-client/src/api/unsplash.ts
+const unsplashImageSchema = z.object({
+	id: z.string(),
+	urls: z.object({
+		raw: z.string(),
+		full: z.string(),
+		regular: z.string(),
+		small: z.string(),
+		thumb: z.string()
+	}),
+	alt_description: z.string().nullable(),
+	description: z.string().nullable(),
+	user: z.object({
+		name: z.string(),
+		username: z.string()
+	}),
+	width: z.number(),
+	height: z.number()
+});
+const unsplashSearchResponseSchema = z.object({
+	results: z.array(unsplashImageSchema),
+	total: z.number(),
+	total_pages: z.number()
+});
+/**
+* Search Unsplash for photos matching a query.
+*/
+async function searchUnsplash(query, accessKey, page = 1, perPage = 20) {
+	const response = await fetch(`https://api.unsplash.com/search/photos?query=${encodeURIComponent(query)}&page=${page}&per_page=${perPage}&client_id=${accessKey}`);
+	if (!response.ok) throw new Error("Failed to search Unsplash");
+	return unsplashSearchResponseSchema.parse(await response.json());
+}
+//#endregion
+//#region ../../file-picker/api-client/src/api/url-proxy.ts
+const urlProxyResponseSchema = z.object({
+	data: z.string(),
+	contentType: z.string(),
+	size: z.number()
+});
+/**
+* Proxy a URL fetch through the backend to bypass CORS restrictions.
+* The backend fetches the file and returns it as base64-encoded data.
+*
+* @param url - The URL to fetch
+* @param proxyEndpoint - The proxy endpoint (defaults to "/api/proxy-url")
+*/
+async function proxyUrlFetch(url, proxyEndpoint = "/api/proxy-url") {
+	const response = await fetch(proxyEndpoint, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ url })
+	});
+	if (!response.ok) {
+		const errorData = await response.json().catch(() => ({ error: "Failed to proxy URL fetch" }));
+		throw new Error(errorData.error || `HTTP ${response.status}`);
+	}
+	const data = await response.json();
+	return urlProxyResponseSchema.parse(data);
+}
+//#endregion
+//#region ../../file-picker/api-client/src/create-file-picker-api.ts
+/**
+* Creates a FilePickerApi-compatible adapter backed by the real API client
+* functions. The returned object satisfies the FilePickerApi interface
+* from @fluid-app/file-picker-core via structural typing.
+*/
+function createFilePickerApi(client) {
+	return {
+		createDamAsset: (params) => createDamAsset(client.fetchClient, params, client.uploadStrategy),
+		queryDamAssets: (params) => queryDamAssets(client.fetchClient, params),
+		searchUnsplash: (query, page, perPage) => {
+			if (!client.unsplashAccessKey) throw new Error("Unsplash access key not configured");
+			return searchUnsplash(query, client.unsplashAccessKey, page, perPage);
+		},
+		deleteDamAsset: (code) => deleteDamAsset(client.fetchClient, code),
+		discardDamAsset: (code) => discardDamAsset(client.fetchClient, code),
+		createDamAssetPathForAssets: (params) => createDamAssetPathForAssets(client.fetchClient, params),
+		proxyUrlFetch: (url) => proxyUrlFetch(url, client.proxyEndpoint)
+	};
+}
+//#endregion
+//#region src/screens/ShareablesScreen.tsx
+/**
+* Parse the current shareables sub-route from the full slug.
+*
+* System nav slugs are "share/products", "share/media", "share/playlists".
+* Detail pages append an ID: "share/products/123", "share/media/456".
+*
+*   "share/products"        → screen="products", detailId=null
+*   "share/products/123"    → screen="products", detailId="123"
+*   "share/media/456"       → screen="media",    detailId="456"
+*   "share/playlists"       → screen="playlists", detailId=null
+*   "share/playlists/789"   → screen="playlists", detailId="789"
+*   "share/files"           → screen="files",    detailId=null
+*   "share"                 → screen=null (default to products)
+*/
+function parseShareablesRoute(currentSlug) {
+	const slugWithoutPrefix = currentSlug.replace(/^share\/?/, "");
+	if (!slugWithoutPrefix) return {
+		screen: null,
+		detailId: null,
+		action: null
+	};
+	const parts = slugWithoutPrefix.split("/");
+	return {
+		screen: parts[0] || null,
+		detailId: parts[1] || null,
+		action: parts[2] || null
+	};
+}
+function ShareablesScreen({ background, textColor, accentColor, padding, borderRadius, ...divProps }) {
+	const domainClient = useSdkClient();
+	const portalProductsApi = usePortalProductsClient();
+	const portalTenantClient = usePortalTenantClient();
+	const { data: userData } = useCurrentUser();
+	const { currentSlug, navigate } = useAppNavigation();
+	const { isCustomer } = useUserType();
+	const fetchProducts = useCallback(async (search, cursor, limit) => {
+		if (search) return portalProductsApi.searchProducts(search, {
+			cursor,
+			limit
+		});
+		return portalProductsApi.listProducts({
+			cursor,
+			limit
+		});
+	}, [portalProductsApi]);
+	const fetchProduct = useCallback(async (id) => portalProductsApi.getProduct(id), [portalProductsApi]);
+	const { screen, detailId, action } = parseShareablesRoute(currentSlug);
+	const handleNavigate = useCallback((subScreen, id) => {
+		navigate(id ? `share/${subScreen}/${id}` : `share/${subScreen}`);
+	}, [navigate]);
+	const handleBack = useCallback(() => {
+		if (detailId && screen) navigate(`share/${screen}`);
+		else navigate("share/products");
+	}, [
+		navigate,
+		detailId,
+		screen
+	]);
+	const coreConfig = useMemo(() => ({
+		client: domainClient,
+		user: userData ? { id: userData.id } : null,
+		repContext: true
+	}), [domainClient, userData]);
+	const playlistsAdapter = useMemo(() => createPortalTenantPlaylistsAdapter(portalTenantClient), [portalTenantClient]);
+	const shareablesApi = useMemo(() => ({
+		media: createPortalTenantMediaShareablesAdapter(portalTenantClient),
+		playlists: createPortalTenantPlaylistsShareablesAdapter(portalTenantClient),
+		fileResources: createPortalTenantFilesShareablesAdapter(portalTenantClient),
+		share: createPortalTenantSharesShareablesAdapter(portalTenantClient),
+		productMedia: { getProductMedia: async (productId) => {
+			return { media: ((await portalProductsApi.getProductMedia(productId)).media ?? []).map((item) => {
+				const isVideo = item.media_type === "video";
+				const isPdf = item.media_type === "pdf" || item.media_type === "document";
+				return {
+					id: item.id ?? 0,
+					slug: null,
+					title: item.title ?? "",
+					kind: isVideo ? "video" : isPdf ? "pdf" : "image",
+					media_type: item.media_type ?? "image",
+					media_format: item.media_type ?? "image",
+					image_url: !isVideo && !isPdf ? item.url ?? null : null,
+					video_url: isVideo ? item.url ?? null : null,
+					pdf_url: isPdf ? item.url ?? null : null,
+					powerpoint_url: null,
+					duration: 0,
+					description: null,
+					subtitles: {},
+					comments_count: 0
+				};
+			}) };
+		} }
+	}), [portalTenantClient, portalProductsApi]);
+	const filePickerApi = useMemo(() => createFilePickerApi(createFilePickerClient({ fetchClient: domainClient })), [domainClient]);
+	const uiConfig = useMemo(() => ({
+		user: userData ? {
+			id: userData.id,
+			company: userData.company ? { logo_url: userData.company.logo_url } : null
+		} : void 0,
+		affiliateId: userData?.affiliate_id ?? null,
+		basePath: "",
+		navigate: (path) => {
+			const cleanPath = path.replace(/^\//, "");
+			navigate(cleanPath.startsWith("share/") ? cleanPath : `share/${cleanPath}`);
+		},
+		showToast: (opts) => {
+			console.warn(`[Shareables] ${opts.type}: ${opts.title}`);
+		},
+		filePickerApi,
+		onToggleFavorite: async (params) => {
+			const affiliateId = userData?.affiliate_id;
+			if (!affiliateId) throw new Error("No affiliate ID");
+			return domainClient.post(`/user_companies/${affiliateId}/favorites/toggle.json`, {
+				favoriteable_id: params.favoriteableId,
+				favoriteable_type: params.favoriteableType
+			});
+		},
+		onDeletePlaylist: isCustomer ? void 0 : async (playlistId) => {
+			await playlistsAdapter.deletePlaylist(playlistId);
+		},
+		readOnly: isCustomer
+	}), [
+		userData,
+		navigate,
+		filePickerApi,
+		domainClient,
+		isCustomer,
+		playlistsAdapter
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		...divProps,
+		className: `h-full ${divProps.className ?? ""}`,
+		children: /* @__PURE__ */ jsx(ShareablesCoreProvider, {
+			config: coreConfig,
+			children: /* @__PURE__ */ jsx(ShareablesApiProvider, {
+				api: shareablesApi,
+				children: /* @__PURE__ */ jsx(ShareablesUIProvider, {
+					config: uiConfig,
+					children: /* @__PURE__ */ jsx(ShareablesApp, {
+						screen,
+						detailId,
+						action,
+						companyLogoUrl: userData?.company?.logo_url,
+						countryCode: userData?.country?.iso,
+						fetchProducts,
+						fetchProduct,
+						onNavigate: handleNavigate,
+						onBack: handleBack
+					})
+				})
+			})
+		})
+	});
+}
+const shareablesScreenPropertySchema = {
+	widgetType: "ShareablesScreen",
+	displayName: "Shareables Screen",
+	tabsConfig: [{
+		id: "styling",
+		label: "Styling"
+	}],
+	fields: []
+};
+//#endregion
+export { shareablesScreenPropertySchema as n, useUserType as r, ShareablesScreen as t };
+
+//# sourceMappingURL=ShareablesScreen-B6tMQzuX.mjs.map