@mundogamernetwork/shared-ui 1.0.0

package/services/httpService.ts

@@ -0,0 +1,95 @@
+import type { UseFetchOptions } from "#app";
+import axios, { type AxiosInstance } from "axios";
+
+let _httpService: AxiosInstance | null = null;
+
+export function getHttpService(): AxiosInstance {
+	if (_httpService) return _httpService;
+
+	_httpService = axios.create({
+		baseURL: import.meta.env.VITE_API_BASE_URL,
+		withCredentials: true,
+	});
+
+	_httpService.interceptors.response.use(
+		(response) => response,
+		(error) => {
+			if (typeof window !== "undefined" && error?.response) {
+				const status = error.response.status;
+				const url = error.config?.url ?? "";
+				const isAuthEndpoint = url.includes("/auth/");
+
+				if (!isAuthEndpoint && (status === 403 || status === 500 || status === 502 || status === 503)) {
+					console.error(`[HTTP] Error ${status}:`, error.response?.data?.message || "");
+				}
+			}
+			return Promise.reject(error);
+		},
+	);
+
+	_httpService.interceptors.request.use((config) => {
+		const SUPPORTED_LOCALES = ["en", "pt-BR", "es", "de", "ro"];
+		const _seg = typeof location === "undefined" ? "" : location.pathname.split("/")[1] || "";
+		const lang = SUPPORTED_LOCALES.includes(_seg) ? _seg : "en";
+
+		config.withCredentials = true;
+		config.params = { ...config.params, lang };
+
+		if (import.meta.env.VITE_APP_ENV !== "production" && typeof window !== "undefined") {
+			if (import.meta.env.VITE_BEARER_TOKEN) {
+				config.headers.Authorization = `Bearer ${import.meta.env.VITE_BEARER_TOKEN}`;
+			}
+			config.headers.set("X-Timezone", Intl.DateTimeFormat().resolvedOptions().timeZone);
+		}
+
+		return config;
+	});
+
+	return _httpService;
+}
+
+const httpService = new Proxy({} as AxiosInstance, {
+	get(_target, prop) {
+		return (getHttpService() as any)[prop];
+	},
+});
+
+export default httpService;
+
+export function mgApiUrl(endpoint: string, usePrefix = true) {
+	const locale = useNuxtApp().$i18n.locale.value;
+	const runtimeConfig = useRuntimeConfig();
+	const apiBaseURL = runtimeConfig.public.mgSharedUi?.apiBaseURL || runtimeConfig.public.apiBaseURL;
+
+	switch (endpoint) {
+		case "login":
+		case "logout":
+		case "register":
+			return [apiBaseURL, usePrefix ? locale : "", endpoint]
+				.filter((v) => v)
+				.map((part) => part.replace(/^\//, ""))
+				.map((part) => part.replace(/\/api\/v1$/, ""))
+				.join("/");
+		default:
+			return [apiBaseURL, usePrefix ? locale : "", endpoint]
+				.filter((v) => v)
+				.map((part) => part.replace(/^\//, ""))
+				.join("/");
+	}
+}
+
+export function useFetchApi<T>(endpoint: string, options?: UseFetchOptions<T>) {
+	const url = mgApiUrl(endpoint);
+	const runtimeConfig = useRuntimeConfig();
+	const headers = useRequestHeaders(["cookie", "authorization"]);
+
+	if (process.env.NODE_ENV === "development" && runtimeConfig.appEnvToken)
+		headers["authorization"] = `Bearer ${runtimeConfig.appEnvToken}`;
+
+	const defaultOptions = {
+		credentials: "include",
+		headers: headers,
+	};
+
+	return $fetch<T>(url, { ...defaultOptions, ...options } as any);
+}

package/services/indieWallService.ts

@@ -0,0 +1,174 @@
+import axios, { type AxiosInstance } from "axios"
+
+// Build a dedicated HTTP client for indie-wall calls.
+// Community-frontend points VITE_INDIE_WALL_API_URL at its main API (api-main).
+// TV / agency leave it unset → falls back to their own VITE_API_BASE_URL.
+let _client: AxiosInstance | null = null
+
+function getClient(): AxiosInstance {
+	if (_client) return _client
+
+	const baseURL =
+		import.meta.env.VITE_INDIE_WALL_API_URL ||
+		import.meta.env.VITE_API_BASE_URL ||
+		""
+
+	_client = axios.create({ baseURL, withCredentials: true })
+
+	_client.interceptors.request.use((config) => {
+		const SUPPORTED_LOCALES = ["en", "pt-BR", "es", "de", "ro", "ar-AE"]
+		const seg =
+			typeof location === "undefined" ? "" : location.pathname.split("/")[1] || ""
+		const lang = SUPPORTED_LOCALES.includes(seg) ? seg : "en"
+		config.params = { ...config.params, lang }
+		if (
+			import.meta.env.VITE_APP_ENV !== "production" &&
+			typeof window !== "undefined" &&
+			import.meta.env.VITE_BEARER_TOKEN
+		) {
+			config.headers.Authorization = `Bearer ${import.meta.env.VITE_BEARER_TOKEN}`
+		}
+		return config
+	})
+
+	return _client
+}
+
+// Lazy proxy so the client is only built after env is resolved.
+const iw = new Proxy({} as AxiosInstance, {
+	get(_t, prop) {
+		return (getClient() as any)[prop]
+	},
+})
+
+export default iw
+
+// ── Public / supporter-facing ──────────────────────────────────────────────
+
+export const fetchPublicWall = (slug: string | number) =>
+	iw.get(`/api/v1/indie-walls/${slug}`)
+
+export const fetchPublicWallGoals = (wallId: string | number) =>
+	iw.get(`/api/v1/indie-walls/${wallId}/goals`)
+
+export const getWallSupporters = (
+	wallId: string | number,
+	params?: Record<string, any>,
+) => {
+	const q = params
+		? "?" +
+			new URLSearchParams(
+				Object.entries(params)
+					.filter(([, v]) => v !== undefined && v !== null)
+					.map(([k, v]) => [k, String(v)]),
+			).toString()
+		: ""
+	return iw.get(`/api/v1/indie-walls/${wallId}/supporters${q}`)
+}
+
+export const suggestPosition = (
+	wallId: string | number,
+	width: number,
+	height: number,
+) =>
+	iw.get(
+		`/api/v1/indie-walls/${wallId}/suggest-position?width=${width}&height=${height}`,
+	)
+
+export const supportIndieWall = (
+	wallId: string | number,
+	data: Record<string, any>,
+) => iw.post(`/api/v1/indie-walls/${wallId}/support`, data)
+
+// ── Owner / dashboard ──────────────────────────────────────────────────────
+
+export const getIndieWall = (id: number | string) =>
+	iw.get(`/api/v1/indie-walls/${id}`)
+
+export const getIndieWalls = (params?: Record<string, any>) => {
+	const q = params
+		? "?" +
+			new URLSearchParams(
+				Object.entries(params)
+					.filter(([, v]) => v !== undefined && v !== null)
+					.map(([k, v]) => [k, String(v)]),
+			).toString()
+		: ""
+	return iw.get(`/api/v1/indie-walls${q}`)
+}
+
+export const getMyIndieWalls = () => iw.get("/api/v1/indie-walls/my-walls")
+
+export const createIndieWall = (data: Record<string, any>) =>
+	iw.post("/api/v1/indie-walls", data)
+
+export const updateIndieWall = (
+	id: number | string,
+	data: Record<string, any>,
+) => iw.put(`/api/v1/indie-walls/${id}`, data)
+
+export const deleteIndieWall = (id: number | string) =>
+	iw.delete(`/api/v1/indie-walls/${id}`)
+
+export const fetchStreamerActiveWalls = (userId: number | string) =>
+	iw.get(`/api/v1/users/${userId}/indie-walls`)
+
+export const addGoalToWall = (wallId: number | string, data: Record<string, any>) =>
+	iw.post(`/api/v1/indie-walls/${wallId}/goals`, data)
+
+export const addTierToWall = (wallId: number | string, data: Record<string, any>) =>
+	iw.post(`/api/v1/indie-walls/${wallId}/tiers`, data)
+
+export const getWidgetToken = (wallId: number | string) =>
+	iw.get(`/api/v1/indie-walls/${wallId}/token`)
+
+export const generateWidgetToken = (wallId: number | string) =>
+	iw.post(`/api/v1/indie-walls/${wallId}/token`)
+
+export const revokeWidgetToken = (wallId: number | string) =>
+	iw.delete(`/api/v1/indie-walls/${wallId}/token`)
+
+export const checkSlugAvailability = (slug: string) =>
+	iw.get(`/api/v1/indie-walls/slug-check?slug=${encodeURIComponent(slug)}`)
+
+export const getWallEventsUrl = (
+	wallId: number | string,
+	token: string,
+): string => {
+	const baseURL =
+		import.meta.env.VITE_INDIE_WALL_API_URL ||
+		import.meta.env.VITE_API_BASE_URL ||
+		""
+	return `${baseURL}/api/v1/indie-walls/${wallId}/events?token=${encodeURIComponent(token)}`
+}
+
+export const fetchMyEarnings = () => iw.get("/api/v1/indie-walls/my-earnings")
+
+export const requestGlobalPayout = () =>
+	iw.post("/api/v1/indie-walls/my-earnings/payout", {})
+
+export const getPaymentSettings = (wallId: number | string) =>
+	iw.get(`/api/v1/indie-walls/${wallId}/payment-settings`)
+
+export const updatePaymentSettings = (
+	wallId: number | string,
+	data: { payout_delay_days?: 7 | 14 | 30; min_payout_amount?: number },
+) => iw.put(`/api/v1/indie-walls/${wallId}/payment-settings`, data)
+
+export const listPayouts = (
+	wallId: number | string,
+	params?: Record<string, any>,
+) => {
+	const q = params
+		? "?" +
+			new URLSearchParams(
+				Object.entries(params)
+					.filter(([, v]) => v !== undefined && v !== null)
+					.map(([k, v]) => [k, String(v)]),
+			).toString()
+		: ""
+	return iw.get(`/api/v1/indie-walls/${wallId}/payouts${q}`)
+}
+
+export const requestPayout = (wallId: number | string) =>
+	iw.post(`/api/v1/indie-walls/${wallId}/payouts`, {})

package/services/institutionalService.ts

@@ -0,0 +1,248 @@
+import httpService from "./httpService";
+import { serialize } from "../utils/serialize";
+
+interface NestedObject {
+	[key: string]: string | string[];
+}
+
+interface SerializeObject {
+	[key: string]: string | NestedObject;
+}
+
+const getNetworkBaseUrl = () => {
+	const config = useRuntimeConfig();
+	return config.public.mgSharedUi?.networkBaseUrl || import.meta.env.VITE_BASE_URL_NETWORK;
+};
+
+export const complexSerialize = function (obj: SerializeObject): string {
+	const searchParams = new URLSearchParams();
+
+	const appendObject = (baseKey: string, object: NestedObject | any) => {
+		Object.entries(object).forEach(([key, value]) => {
+			if (typeof value === "object" && value !== null) {
+				appendObject(`${baseKey}[${key}]`, value);
+			} else {
+				searchParams.append(`${baseKey}[${key}]`, value.toString());
+			}
+		});
+	};
+
+	for (const key in obj) {
+		const item = obj[key];
+		if (Array.isArray(item)) {
+			item.forEach((arrayItem: any, index: number) => {
+				if (typeof arrayItem === "object" && arrayItem !== null) {
+					appendObject(`${key}[${index}]`, arrayItem);
+				} else {
+					searchParams.append(`${key}[${index}]`, arrayItem.toString());
+				}
+			});
+		} else if (typeof item === "object" && item !== null) {
+			appendObject(key, item);
+		} else {
+			searchParams.append(key, item.toString());
+		}
+	}
+
+	return `?${decodeURIComponent(searchParams.toString())}`;
+};
+
+export const fetchPress = async (lang: string, params: SerializeObject): Promise<any> => {
+	params["filter[language]"] = lang;
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/press-posts${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchCareer = async (lang: string, params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/careers${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchStatus = async (lang: string, params: SerializeObject): Promise<any> => {
+	params["filter[language]"] = lang;
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/network-systems${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchGeneralStatus = async (lang: string, params: SerializeObject): Promise<any> => {
+	params["filter[language]"] = lang;
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/network-systems-general-status${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchRoadmap = async (lang: string, params: SerializeObject): Promise<any> => {
+	params["filter[language]"] = lang;
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/roadmaps-public${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchCountry = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/careers-countries${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchDepartment = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/operational-area-careers${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchTeam = async (lang: string, params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/teams-members-public${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchOperationalArea = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/operational-areas-public${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchPartner = async (lang: string, params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/partners-public${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchBlog = async (lang: string, params: SerializeObject): Promise<any> => {
+	params["filter[language]"] = lang;
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/blog-posts${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchBlogCategory = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/blog-categories${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchBlogTag = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/blog-tags${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchFaq = async (lang: string, params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/faq${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchMagazine = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/public/magazines${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const fetchMagazines = async (id: number): Promise<any> => {
+	return httpService({
+		url: `/public/magazines/${id}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const getMagazine = async (magazine: string): Promise<any> => {
+	return httpService({
+		url: `/public/magazines/${magazine}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const getMagazinePages = async (slug: string): Promise<any> => {
+	return httpService({
+		url: `/public/magazines/${slug}/pages`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const trackMagazineAnalytic = async (slug: string, eventType: string): Promise<any> => {
+	return httpService({
+		url: `/public/magazines/${slug}/analytics`,
+		baseURL: getNetworkBaseUrl(),
+		method: "POST",
+		data: { event_type: eventType },
+	});
+};
+
+export const captureMagazineLead = async (slug: string, name: string, email: string): Promise<any> => {
+	return httpService({
+		url: `/public/magazines/${slug}/leads`,
+		baseURL: getNetworkBaseUrl(),
+		method: "POST",
+		data: { name, email },
+	});
+};
+
+export const fetchLanguage = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/languages${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+	});
+};
+
+export const storeNewsletter = async (lang: string, params: SerializeObject): Promise<any> => {
+	params["filter[language]"] = lang;
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/newsletters${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+		method: "POST",
+	});
+};
+
+export const fetchNewsletter = async (lang: string, params: SerializeObject): Promise<any> => {
+	params["filter[language]"] = lang;
+	const paramsSerialized = complexSerialize(params);
+	return httpService({
+		url: `/newsletters${paramsSerialized}`,
+		baseURL: getNetworkBaseUrl(),
+		method: "POST",
+	});
+};
+
+export const fetchTopCompany = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized = serialize(params);
+	return httpService({
+		url: `/companies/top${paramsSerialized}`,
+		baseURL: import.meta.env.VITE_API_BASE_URL,
+	});
+};

package/services/mediaKitService.ts

@@ -0,0 +1,51 @@
+import axios, { type AxiosInstance } from "axios"
+
+// Media-kit data lives in the TV API.
+// TV / agency leave VITE_MEDIA_KIT_API_URL unset → fall back to VITE_API_BASE_URL.
+// Community sets VITE_MEDIA_KIT_API_URL=https://api-tv.mgnetwork.xyz
+let _client: AxiosInstance | null = null
+
+function getClient(): AxiosInstance {
+	if (_client) return _client
+
+	const baseURL =
+		import.meta.env.VITE_MEDIA_KIT_API_URL ||
+		import.meta.env.VITE_API_BASE_URL ||
+		""
+
+	_client = axios.create({ baseURL, withCredentials: true })
+
+	_client.interceptors.request.use((config) => {
+		const SUPPORTED_LOCALES = ["en", "pt-BR", "es", "de", "ro", "ar-AE"]
+		const seg =
+			typeof location === "undefined" ? "" : location.pathname.split("/")[1] || ""
+		const lang = SUPPORTED_LOCALES.includes(seg) ? seg : "en"
+		config.params = { ...config.params, lang }
+		if (
+			import.meta.env.VITE_APP_ENV !== "production" &&
+			typeof window !== "undefined" &&
+			import.meta.env.VITE_BEARER_TOKEN
+		) {
+			config.headers.Authorization = `Bearer ${import.meta.env.VITE_BEARER_TOKEN}`
+		}
+		return config
+	})
+
+	return _client
+}
+
+const mk = new Proxy({} as AxiosInstance, {
+	get(_t, prop) {
+		return (getClient() as any)[prop]
+	},
+})
+
+export default mk
+
+export const fetchPublicMediaKit = (slug: string) =>
+	mk.get(`/api/v1/media-kit/${slug}`)
+
+export const trackMediaKitEvent = (
+	userId: number | string,
+	data: { type?: "view" | "click" | "download" | "contact"; referrer?: string } = {},
+) => mk.post(`/api/v1/media-kit/${userId}/track`, data)

package/services/notificationsService.ts

@@ -0,0 +1,20 @@
+import httpService from "./httpService";
+import { serialize, type SerializeObject } from "../utils/serialize";
+
+export const getAllNotifications = async (params: SerializeObject): Promise<any> => {
+	const paramsSerialized: string = serialize(params);
+	return await httpService.get(`/public/user/notifications${paramsSerialized}`);
+};
+
+export const markNotificationAsRead = async (notificationId: string): Promise<any> => {
+	return await httpService.get(`/public/user/notifications/${notificationId}`);
+};
+
+export const markAllNotificationsAsRead = async (): Promise<any> => {
+	const response = await httpService.post(`/public/user/notifications/mark-all-as-read`);
+	if (response.status === 200) return response.data;
+};
+
+export const deleteNotification = async (notificationId: string): Promise<any> => {
+	return await httpService.delete(`/public/user/notifications/${notificationId}`);
+};

package/services/pressKitService.ts

@@ -0,0 +1,55 @@
+import axios, { type AxiosInstance } from "axios"
+
+// Press-kit data lives in the Agency API.
+// Agency leaves VITE_PRESS_KIT_API_URL unset → falls back to VITE_API_BASE_URL.
+// Community sets VITE_PRESS_KIT_API_URL=https://api-agency.mgnetwork.xyz/api/v1
+let _client: AxiosInstance | null = null
+
+function getClient(): AxiosInstance {
+	if (_client) return _client
+
+	const baseURL =
+		import.meta.env.VITE_PRESS_KIT_API_URL ||
+		import.meta.env.VITE_API_BASE_URL ||
+		""
+
+	_client = axios.create({ baseURL, withCredentials: true })
+
+	_client.interceptors.request.use((config) => {
+		const SUPPORTED_LOCALES = ["en", "pt-BR", "es", "de", "ro", "ar-AE"]
+		const seg =
+			typeof location === "undefined" ? "" : location.pathname.split("/")[1] || ""
+		const lang = SUPPORTED_LOCALES.includes(seg) ? seg : "en"
+		config.params = { ...config.params, lang }
+		if (
+			import.meta.env.VITE_APP_ENV !== "production" &&
+			typeof window !== "undefined" &&
+			import.meta.env.VITE_BEARER_TOKEN
+		) {
+			config.headers.Authorization = `Bearer ${import.meta.env.VITE_BEARER_TOKEN}`
+		}
+		return config
+	})
+
+	return _client
+}
+
+const pk = new Proxy({} as AxiosInstance, {
+	get(_t, prop) {
+		return (getClient() as any)[prop]
+	},
+})
+
+export default pk
+
+export const fetchPublicPressKit = (slug: string) =>
+	pk.get(`/public/press-kits/${slug}?include=assets,videos,credits,awards,quotes`)
+
+export const trackPressKitEvent = (
+	slug: string,
+	data: {
+		event_type: "view" | "click" | "download" | "contact"
+		referrer?: string
+		metadata?: Record<string, any>
+	},
+) => pk.post(`/public/press-kits/${slug}/analytics`, data)