@mundogamernetwork/shared-ui 1.18.2 → 1.19.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +3 -3
- package/components/ui/MgHeaderComponent.vue +11 -0
- package/components/ui/MgHeaderUIUser.vue +9 -0
- package/components/whats-new/MgWhatsNewDrawer.vue +468 -0
- package/components/whats-new/MgWhatsNewHistory.vue +120 -0
- package/components/whats-new/MgWhatsNewMenuItem.vue +92 -0
- package/nuxt.config.ts +4 -2
- package/package.json +1 -1
- package/stores/whatsNew.ts +177 -3
- package/utils/whatsNew.ts +31 -0
- package/utils/whatsNewMessages.ts +72 -0
package/README.md
CHANGED
|
@@ -203,21 +203,21 @@ Também pode ser usado direto: `<MgWhatsNewModal :suppress="meuModalAberto" :blo
|
|
|
203
203
|
|
|
204
204
|
O plugin `presence.client` avisa a API, a cada ~2 minutos e só com a aba visível, que o usuário logado está ativo na plataforma. O network-admin usa isso para mostrar "Online" e "Última atividade" na lista de usuários e para os fluxos de reativação.
|
|
205
205
|
|
|
206
|
-
**Desligado por padrão.** Ligue por front
|
|
206
|
+
**Desligado por padrão.** Ligue por front quando a API desse front já rodar a versão do api-main que guarda o heartbeat no Redis (antes disso cada ping vira uma escrita no Postgres). O plugin usa o `VITE_SYSTEM_ID` do front como plataforma.
|
|
207
207
|
|
|
208
208
|
```ts
|
|
209
209
|
// nuxt.config.ts do app
|
|
210
210
|
runtimeConfig: {
|
|
211
211
|
public: {
|
|
212
212
|
mgSharedUi: {
|
|
213
|
-
systemId: '1', //
|
|
213
|
+
systemId: '1', // opcional se VITE_SYSTEM_ID já estiver definido
|
|
214
214
|
presence: { enabled: true, intervalSeconds: 120 } // nunca abaixo de 60
|
|
215
215
|
}
|
|
216
216
|
}
|
|
217
217
|
}
|
|
218
218
|
```
|
|
219
219
|
|
|
220
|
-
|
|
220
|
+
Ou, sem mexer no código (vale em runtime): `NUXT_PUBLIC_MG_SHARED_UI_PRESENCE_ENABLED=true`.
|
|
221
221
|
|
|
222
222
|
- Chama `POST /public/user-status/heartbeat` com `{ platform_id }`. Sem `systemId` numérico, o plugin não faz nada.
|
|
223
223
|
- Acompanha o login pelo store `auth-store`, então funciona também nos apps que têm cópia própria do store (academy, agency) com o mesmo id.
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
<script setup lang="ts">
|
|
2
2
|
import { ref } from "vue";
|
|
3
3
|
import { storeToRefs } from "pinia";
|
|
4
|
+
import { formatBadge } from "../../utils/whatsNew";
|
|
4
5
|
|
|
5
6
|
const authStore = useAuthStore();
|
|
6
7
|
const indexStore = useIndexStore();
|
|
@@ -9,6 +10,12 @@ const notificationsStore = useNotificationsStore();
|
|
|
9
10
|
const { user, signedIn } = storeToRefs(authStore);
|
|
10
11
|
const { notificationCount } = storeToRefs(notificationsStore);
|
|
11
12
|
|
|
13
|
+
// "Novidades" history: the unread number rides on the profile avatar (the drawer opens from the user menu).
|
|
14
|
+
const whatsNewStore = useWhatsNewStore();
|
|
15
|
+
const whatsNewCfg: any = useRuntimeConfig().public.mgSharedUi?.whatsNew ?? {};
|
|
16
|
+
const whatsNewHistory = whatsNewCfg.enabled !== false && whatsNewCfg.history !== false;
|
|
17
|
+
const whatsNewBadge = computed(() => (whatsNewHistory && signedIn.value ? formatBadge(whatsNewStore.unread) : ""));
|
|
18
|
+
|
|
12
19
|
const runtimeConfig = useRuntimeConfig();
|
|
13
20
|
const features = runtimeConfig.public.mgSharedUi?.features ?? {};
|
|
14
21
|
|
|
@@ -117,6 +124,7 @@ onMounted(() => {
|
|
|
117
124
|
class="rounded-circle"
|
|
118
125
|
@error="(e: Event) => { const t = e.target as HTMLImageElement; if (t) { t.onerror = null; t.src = '/imgs/default-avatar.png' } }"
|
|
119
126
|
/>
|
|
127
|
+
<span v-if="whatsNewBadge" class="badge" aria-hidden="true">{{ whatsNewBadge }}</span>
|
|
120
128
|
</a>
|
|
121
129
|
</li>
|
|
122
130
|
|
|
@@ -136,6 +144,9 @@ onMounted(() => {
|
|
|
136
144
|
/>
|
|
137
145
|
</transition>
|
|
138
146
|
|
|
147
|
+
<!-- Drawer + reopened announcement of the "Novidades" history: outside the dropdown so they outlive it. -->
|
|
148
|
+
<MgWhatsNewHistory v-if="signedIn" />
|
|
149
|
+
|
|
139
150
|
<transition name="fade">
|
|
140
151
|
<MgNotificationsModal
|
|
141
152
|
v-if="showNotifications"
|
|
@@ -26,6 +26,11 @@ const runtimeConfig = useRuntimeConfig();
|
|
|
26
26
|
const accountsBaseUrl = runtimeConfig.public.mgSharedUi?.accountsBaseUrl || runtimeConfig.public.accountsBaseUrl;
|
|
27
27
|
const supportUrl = `${accountsBaseUrl}/account/support/new`;
|
|
28
28
|
const features = runtimeConfig.public.mgSharedUi?.features ?? {};
|
|
29
|
+
// "Novidades" history entry (drawer mounted by MgHeaderComponent). On unless the front switches it off.
|
|
30
|
+
const whatsNewConfig: any = runtimeConfig.public.mgSharedUi?.whatsNew ?? {};
|
|
31
|
+
const whatsNewHistory = whatsNewConfig.enabled !== false && whatsNewConfig.history !== false;
|
|
32
|
+
// The entry only shows when the drawer host is mounted (MgHeaderComponent does it); a custom header without it hides the entry.
|
|
33
|
+
const whatsNewStore = useWhatsNewStore();
|
|
29
34
|
const pricingUrl = runtimeConfig.public.mgSharedUi?.pricingUrl || "";
|
|
30
35
|
const { locale } = useI18n();
|
|
31
36
|
|
|
@@ -214,6 +219,10 @@ const handleToggleOnline = () => {
|
|
|
214
219
|
</a>
|
|
215
220
|
</div>
|
|
216
221
|
|
|
222
|
+
<div v-if="whatsNewHistory && whatsNewStore.hostMounted" class="row info-row">
|
|
223
|
+
<MgWhatsNewMenuItem @opened="emit('toggleVisible')" />
|
|
224
|
+
</div>
|
|
225
|
+
|
|
217
226
|
<div class="row info-row">
|
|
218
227
|
<a :href="accountsBaseUrl" target="_blank" class="btn btn-primary-outline mt-3">
|
|
219
228
|
{{ $t("account_menu.buttons.manage_account") }}
|
|
@@ -0,0 +1,468 @@
|
|
|
1
|
+
<script setup lang="ts">
|
|
2
|
+
/**
|
|
3
|
+
* Side drawer with the history of announcements ("Novidades"). Reads the store directly; the host
|
|
4
|
+
* (<MgWhatsNewHistory />) decides what happens when a row is opened. Colours come only from the
|
|
5
|
+
* --mg-wn-* tokens, layout is logical (RTL aware), and the focus is trapped while it is open.
|
|
6
|
+
*/
|
|
7
|
+
import { computed, nextTick, onBeforeUnmount, onMounted, ref } from "vue";
|
|
8
|
+
import { formatBadge, isRtl, parseRich, richToPlain, toApiLang, type WnHistoryItem } from "../../utils/whatsNew";
|
|
9
|
+
import { wnText, type WnTextKey } from "../../utils/whatsNewText";
|
|
10
|
+
|
|
11
|
+
const props = defineProps<{ locale: string }>();
|
|
12
|
+
const emit = defineEmits<{
|
|
13
|
+
(e: "close"): void;
|
|
14
|
+
(e: "open", item: WnHistoryItem): void;
|
|
15
|
+
(e: "more"): void;
|
|
16
|
+
(e: "retry"): void;
|
|
17
|
+
}>();
|
|
18
|
+
|
|
19
|
+
const store = useWhatsNewStore();
|
|
20
|
+
const uid = Math.random().toString(36).slice(2, 8);
|
|
21
|
+
const titleId = `mg-wn-drawer-title-${uid}`;
|
|
22
|
+
|
|
23
|
+
const panel = ref<HTMLElement | null>(null);
|
|
24
|
+
const titleEl = ref<HTMLElement | null>(null);
|
|
25
|
+
let returnFocusTo: HTMLElement | null = null;
|
|
26
|
+
let previousOverflow = "";
|
|
27
|
+
|
|
28
|
+
const t = (key: WnTextKey) => wnText(props.locale, key);
|
|
29
|
+
const dir = computed(() => (isRtl(props.locale) ? "rtl" : "ltr"));
|
|
30
|
+
const badge = computed(() => formatBadge(store.unread));
|
|
31
|
+
const hasMore = computed(() => !!store.historyMeta && store.historyMeta.page < store.historyMeta.last_page);
|
|
32
|
+
const loading = computed(() => store.historyStatus === "loading");
|
|
33
|
+
|
|
34
|
+
const dateFormat = computed(() => {
|
|
35
|
+
try {
|
|
36
|
+
return new Intl.DateTimeFormat(toApiLang(props.locale), { dateStyle: "medium" });
|
|
37
|
+
} catch {
|
|
38
|
+
return null;
|
|
39
|
+
}
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
function dateOf(iso: string | null): string {
|
|
43
|
+
if (!iso || !dateFormat.value) return "";
|
|
44
|
+
const d = new Date(iso);
|
|
45
|
+
return Number.isNaN(d.getTime()) ? "" : dateFormat.value.format(d);
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
function kindLabel(item: WnHistoryItem) {
|
|
49
|
+
return t(`kind_${item.kind}` as WnTextKey);
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
function rowLabel(item: WnHistoryItem) {
|
|
53
|
+
return [item.is_new ? t("history_new") : "", item.title, kindLabel(item), dateOf(item.published_at)]
|
|
54
|
+
.filter(Boolean)
|
|
55
|
+
.join(", ");
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** The list shows plain text: `**bold**` and `[text](url)` in the summary are flattened. */
|
|
59
|
+
function summaryOf(item: WnHistoryItem): string {
|
|
60
|
+
return richToPlain(parseRich(item.summary, false));
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
function onBackdrop(event: MouseEvent) {
|
|
64
|
+
if (event.target === event.currentTarget) emit("close");
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
// ── focus management ──────────────────────────────────────────────────────
|
|
68
|
+
const FOCUSABLE = 'a[href], button:not([disabled]), [tabindex]:not([tabindex="-1"])';
|
|
69
|
+
|
|
70
|
+
function focusables(): HTMLElement[] {
|
|
71
|
+
if (!panel.value) return [];
|
|
72
|
+
return Array.from(panel.value.querySelectorAll<HTMLElement>(FOCUSABLE)).filter((el) => el.getClientRects().length > 0);
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
function onKeydown(event: KeyboardEvent) {
|
|
76
|
+
// A reopened announcement sits on top with its own handler: leave Esc and Tab to it.
|
|
77
|
+
if (store.viewing) return;
|
|
78
|
+
if (event.key === "Escape") {
|
|
79
|
+
event.stopPropagation();
|
|
80
|
+
emit("close");
|
|
81
|
+
return;
|
|
82
|
+
}
|
|
83
|
+
if (event.key !== "Tab") return;
|
|
84
|
+
const items = focusables();
|
|
85
|
+
if (!items.length) {
|
|
86
|
+
event.preventDefault();
|
|
87
|
+
titleEl.value?.focus();
|
|
88
|
+
return;
|
|
89
|
+
}
|
|
90
|
+
const first = items[0];
|
|
91
|
+
const last = items[items.length - 1];
|
|
92
|
+
const active = document.activeElement as HTMLElement | null;
|
|
93
|
+
const inside = !!active && !!panel.value?.contains(active);
|
|
94
|
+
if (event.shiftKey && (active === first || active === titleEl.value || !inside)) {
|
|
95
|
+
event.preventDefault();
|
|
96
|
+
last.focus();
|
|
97
|
+
} else if (!event.shiftKey && (active === last || !inside)) {
|
|
98
|
+
event.preventDefault();
|
|
99
|
+
first.focus();
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
onMounted(async () => {
|
|
104
|
+
returnFocusTo = document.activeElement instanceof HTMLElement ? document.activeElement : null;
|
|
105
|
+
previousOverflow = document.documentElement.style.overflow;
|
|
106
|
+
document.documentElement.style.overflow = "hidden";
|
|
107
|
+
document.addEventListener("keydown", onKeydown, true);
|
|
108
|
+
await nextTick();
|
|
109
|
+
titleEl.value?.focus({ preventScroll: true });
|
|
110
|
+
});
|
|
111
|
+
|
|
112
|
+
onBeforeUnmount(() => {
|
|
113
|
+
document.removeEventListener("keydown", onKeydown, true);
|
|
114
|
+
document.documentElement.style.overflow = previousOverflow;
|
|
115
|
+
if (returnFocusTo && document.contains(returnFocusTo)) returnFocusTo.focus({ preventScroll: true });
|
|
116
|
+
});
|
|
117
|
+
</script>
|
|
118
|
+
|
|
119
|
+
<template>
|
|
120
|
+
<div class="mg-wn-drawer-overlay" data-mg-wn :dir="dir" @mousedown="onBackdrop">
|
|
121
|
+
<aside ref="panel" class="mg-wn-drawer" role="dialog" aria-modal="true" :aria-labelledby="titleId" :aria-busy="loading">
|
|
122
|
+
<header class="mg-wn-drawer__head">
|
|
123
|
+
<div class="mg-wn-drawer__head-text">
|
|
124
|
+
<h2 :id="titleId" ref="titleEl" class="mg-wn-drawer__title" tabindex="-1">
|
|
125
|
+
{{ t("history_title") }}
|
|
126
|
+
<span v-if="badge" class="mg-wn-drawer__count" :aria-label="`${store.unread} ${t('history_unread')}`">{{ badge }}</span>
|
|
127
|
+
</h2>
|
|
128
|
+
<p class="mg-wn-drawer__sub">{{ t("history_subtitle") }}</p>
|
|
129
|
+
</div>
|
|
130
|
+
<button type="button" class="mg-wn-drawer__x" :aria-label="t('close')" @click="emit('close')">
|
|
131
|
+
<span aria-hidden="true">✕</span>
|
|
132
|
+
</button>
|
|
133
|
+
</header>
|
|
134
|
+
|
|
135
|
+
<p v-if="store.openError" class="mg-wn-drawer__alert" role="alert">{{ t("history_open_error") }}</p>
|
|
136
|
+
|
|
137
|
+
<div class="mg-wn-drawer__body">
|
|
138
|
+
<p v-if="loading" class="mg-wn-drawer__state" role="status">{{ t("history_loading") }}</p>
|
|
139
|
+
|
|
140
|
+
<div v-else-if="store.historyStatus === 'error' && !store.history.length" class="mg-wn-drawer__state" role="alert">
|
|
141
|
+
<p>{{ t("history_error") }}</p>
|
|
142
|
+
<button type="button" class="mg-wn-drawer__btn" @click="emit('retry')">{{ t("history_retry") }}</button>
|
|
143
|
+
</div>
|
|
144
|
+
|
|
145
|
+
<p v-else-if="!store.history.length" class="mg-wn-drawer__state">{{ t("history_empty") }}</p>
|
|
146
|
+
|
|
147
|
+
<ul v-else class="mg-wn-drawer__list">
|
|
148
|
+
<li v-for="item in store.history" :key="item.id">
|
|
149
|
+
<button
|
|
150
|
+
type="button"
|
|
151
|
+
class="mg-wn-row"
|
|
152
|
+
:class="{ 'mg-wn-row--new': item.is_new }"
|
|
153
|
+
:aria-label="rowLabel(item)"
|
|
154
|
+
:aria-busy="store.openingId === item.id"
|
|
155
|
+
:disabled="store.openingId !== null"
|
|
156
|
+
@click="emit('open', item)"
|
|
157
|
+
>
|
|
158
|
+
<img v-if="item.thumb_url" :src="item.thumb_url" alt="" class="mg-wn-row__thumb" loading="lazy" width="72" height="72" />
|
|
159
|
+
<span class="mg-wn-row__text">
|
|
160
|
+
<span class="mg-wn-row__meta">
|
|
161
|
+
<span class="mg-wn-row__kind" :class="`mg-wn-row__kind--${item.kind}`">{{ kindLabel(item) }}</span>
|
|
162
|
+
<span v-if="dateOf(item.published_at)" class="mg-wn-row__date">{{ dateOf(item.published_at) }}</span>
|
|
163
|
+
<span v-if="item.is_new" class="mg-wn-row__new">{{ t("history_new") }}</span>
|
|
164
|
+
</span>
|
|
165
|
+
<span class="mg-wn-row__title">{{ item.title }}</span>
|
|
166
|
+
<span v-if="summaryOf(item)" class="mg-wn-row__summary">{{ summaryOf(item) }}</span>
|
|
167
|
+
</span>
|
|
168
|
+
</button>
|
|
169
|
+
</li>
|
|
170
|
+
</ul>
|
|
171
|
+
|
|
172
|
+
<div v-if="store.history.length && (hasMore || store.historyStatus === 'loadingMore' || store.historyStatus === 'error')" class="mg-wn-drawer__more">
|
|
173
|
+
<p v-if="store.historyStatus === 'loadingMore'" role="status">{{ t("history_loading") }}</p>
|
|
174
|
+
<template v-else-if="store.historyStatus === 'error'">
|
|
175
|
+
<p role="alert">{{ t("history_error") }}</p>
|
|
176
|
+
<button type="button" class="mg-wn-drawer__btn" @click="emit('more')">{{ t("history_retry") }}</button>
|
|
177
|
+
</template>
|
|
178
|
+
<button v-else type="button" class="mg-wn-drawer__btn" @click="emit('more')">{{ t("history_more") }}</button>
|
|
179
|
+
</div>
|
|
180
|
+
</div>
|
|
181
|
+
</aside>
|
|
182
|
+
</div>
|
|
183
|
+
</template>
|
|
184
|
+
|
|
185
|
+
<style lang="scss" scoped>
|
|
186
|
+
.mg-wn-drawer-overlay {
|
|
187
|
+
position: fixed;
|
|
188
|
+
inset: 0;
|
|
189
|
+
z-index: 10040; // under the announcement dialog (10050), which opens on top of the drawer
|
|
190
|
+
display: flex;
|
|
191
|
+
justify-content: flex-end; // inline-end: right in LTR, left in RTL
|
|
192
|
+
background: var(--mg-wn-overlay);
|
|
193
|
+
font-family: inherit;
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
.mg-wn-drawer {
|
|
197
|
+
display: flex;
|
|
198
|
+
flex-direction: column;
|
|
199
|
+
width: min(420px, 100vw);
|
|
200
|
+
height: 100%;
|
|
201
|
+
color: var(--mg-wn-text);
|
|
202
|
+
background: var(--mg-wn-surface);
|
|
203
|
+
border-inline-start: 1px solid var(--mg-wn-border);
|
|
204
|
+
box-shadow: 0 0 40px var(--mg-wn-shadow);
|
|
205
|
+
animation: mg-wn-drawer-in 0.2s ease-out;
|
|
206
|
+
|
|
207
|
+
&:focus-visible,
|
|
208
|
+
& :focus-visible {
|
|
209
|
+
outline: 2px solid var(--mg-wn-accent);
|
|
210
|
+
outline-offset: 2px;
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
&__head {
|
|
214
|
+
display: flex;
|
|
215
|
+
align-items: flex-start;
|
|
216
|
+
justify-content: space-between;
|
|
217
|
+
gap: 12px;
|
|
218
|
+
padding: 16px 18px 12px;
|
|
219
|
+
border-bottom: 1px solid var(--mg-wn-border);
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
&__head-text {
|
|
223
|
+
min-width: 0;
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
&__title {
|
|
227
|
+
display: flex;
|
|
228
|
+
align-items: center;
|
|
229
|
+
gap: 8px;
|
|
230
|
+
margin: 0;
|
|
231
|
+
font-size: 1.25rem;
|
|
232
|
+
line-height: 1.25;
|
|
233
|
+
font-weight: 700;
|
|
234
|
+
|
|
235
|
+
&:focus {
|
|
236
|
+
outline: none;
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
&__count {
|
|
241
|
+
min-width: 20px;
|
|
242
|
+
height: 20px;
|
|
243
|
+
padding: 0 6px;
|
|
244
|
+
display: inline-flex;
|
|
245
|
+
align-items: center;
|
|
246
|
+
justify-content: center;
|
|
247
|
+
font-size: 0.6875rem;
|
|
248
|
+
font-weight: 700;
|
|
249
|
+
color: var(--mg-wn-on-accent);
|
|
250
|
+
background: var(--mg-wn-accent);
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
&__sub {
|
|
254
|
+
margin: 4px 0 0;
|
|
255
|
+
font-size: 0.8125rem;
|
|
256
|
+
color: var(--mg-wn-text-muted);
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
&__x {
|
|
260
|
+
flex: none;
|
|
261
|
+
display: grid;
|
|
262
|
+
place-items: center;
|
|
263
|
+
width: 32px;
|
|
264
|
+
height: 32px;
|
|
265
|
+
padding: 0;
|
|
266
|
+
font-size: 0.875rem;
|
|
267
|
+
color: var(--mg-wn-text-muted);
|
|
268
|
+
background: transparent;
|
|
269
|
+
border: 1px solid var(--mg-wn-border);
|
|
270
|
+
border-radius: 0;
|
|
271
|
+
cursor: pointer;
|
|
272
|
+
|
|
273
|
+
&:hover {
|
|
274
|
+
color: var(--mg-wn-text);
|
|
275
|
+
background: var(--mg-wn-surface-2);
|
|
276
|
+
}
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
&__alert {
|
|
280
|
+
margin: 0;
|
|
281
|
+
padding: 10px 18px;
|
|
282
|
+
font-size: 0.8125rem;
|
|
283
|
+
color: var(--mg-wn-warning);
|
|
284
|
+
background: var(--mg-wn-surface-2);
|
|
285
|
+
border-bottom: 1px solid var(--mg-wn-border);
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
&__body {
|
|
289
|
+
flex: 1;
|
|
290
|
+
overflow-y: auto;
|
|
291
|
+
overscroll-behavior: contain;
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
&__state {
|
|
295
|
+
margin: 0;
|
|
296
|
+
padding: 32px 18px;
|
|
297
|
+
text-align: center;
|
|
298
|
+
font-size: 0.9rem;
|
|
299
|
+
color: var(--mg-wn-text-muted);
|
|
300
|
+
|
|
301
|
+
p {
|
|
302
|
+
margin: 0 0 12px;
|
|
303
|
+
}
|
|
304
|
+
}
|
|
305
|
+
|
|
306
|
+
&__list {
|
|
307
|
+
list-style: none;
|
|
308
|
+
margin: 0;
|
|
309
|
+
padding: 0;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
&__more {
|
|
313
|
+
padding: 14px 18px 20px;
|
|
314
|
+
text-align: center;
|
|
315
|
+
font-size: 0.8125rem;
|
|
316
|
+
color: var(--mg-wn-text-muted);
|
|
317
|
+
|
|
318
|
+
p {
|
|
319
|
+
margin: 0 0 10px;
|
|
320
|
+
}
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
&__btn {
|
|
324
|
+
padding: 8px 16px;
|
|
325
|
+
font: inherit;
|
|
326
|
+
font-size: 0.8125rem;
|
|
327
|
+
font-weight: 600;
|
|
328
|
+
color: var(--mg-wn-accent);
|
|
329
|
+
background: transparent;
|
|
330
|
+
border: 1px solid var(--mg-wn-accent);
|
|
331
|
+
border-radius: 0;
|
|
332
|
+
cursor: pointer;
|
|
333
|
+
|
|
334
|
+
&:hover {
|
|
335
|
+
color: var(--mg-wn-on-accent);
|
|
336
|
+
background: var(--mg-wn-accent);
|
|
337
|
+
}
|
|
338
|
+
}
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
.mg-wn-row {
|
|
342
|
+
display: flex;
|
|
343
|
+
align-items: flex-start;
|
|
344
|
+
gap: 12px;
|
|
345
|
+
width: 100%;
|
|
346
|
+
padding: 14px 18px;
|
|
347
|
+
font: inherit;
|
|
348
|
+
text-align: start;
|
|
349
|
+
color: var(--mg-wn-text);
|
|
350
|
+
background: transparent;
|
|
351
|
+
border: 0;
|
|
352
|
+
border-bottom: 1px solid var(--mg-wn-border);
|
|
353
|
+
cursor: pointer;
|
|
354
|
+
|
|
355
|
+
&:hover:not(:disabled) {
|
|
356
|
+
background: var(--mg-wn-surface-2);
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
&:disabled {
|
|
360
|
+
cursor: progress;
|
|
361
|
+
opacity: 0.7;
|
|
362
|
+
}
|
|
363
|
+
|
|
364
|
+
&--new {
|
|
365
|
+
border-inline-start: 3px solid var(--mg-wn-accent);
|
|
366
|
+
padding-inline-start: 15px;
|
|
367
|
+
}
|
|
368
|
+
|
|
369
|
+
&__thumb {
|
|
370
|
+
flex: none;
|
|
371
|
+
width: 72px;
|
|
372
|
+
height: 72px;
|
|
373
|
+
object-fit: cover;
|
|
374
|
+
background: var(--mg-wn-media-bg);
|
|
375
|
+
}
|
|
376
|
+
|
|
377
|
+
&__text {
|
|
378
|
+
display: flex;
|
|
379
|
+
flex-direction: column;
|
|
380
|
+
gap: 4px;
|
|
381
|
+
min-width: 0;
|
|
382
|
+
}
|
|
383
|
+
|
|
384
|
+
&__meta {
|
|
385
|
+
display: flex;
|
|
386
|
+
flex-wrap: wrap;
|
|
387
|
+
align-items: center;
|
|
388
|
+
gap: 8px;
|
|
389
|
+
font-size: 0.6875rem;
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
&__kind {
|
|
393
|
+
font-weight: 700;
|
|
394
|
+
letter-spacing: 0.08em;
|
|
395
|
+
text-transform: uppercase;
|
|
396
|
+
color: var(--mg-wn-neutral);
|
|
397
|
+
|
|
398
|
+
&--release {
|
|
399
|
+
color: var(--mg-wn-accent);
|
|
400
|
+
}
|
|
401
|
+
|
|
402
|
+
&--launch {
|
|
403
|
+
color: var(--mg-wn-success);
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
&--maintenance {
|
|
407
|
+
color: var(--mg-wn-warning);
|
|
408
|
+
}
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
&__date {
|
|
412
|
+
color: var(--mg-wn-text-muted);
|
|
413
|
+
}
|
|
414
|
+
|
|
415
|
+
&__new {
|
|
416
|
+
padding: 1px 6px;
|
|
417
|
+
font-weight: 700;
|
|
418
|
+
color: var(--mg-wn-on-accent);
|
|
419
|
+
background: var(--mg-wn-accent);
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
&__title {
|
|
423
|
+
font-size: 0.95rem;
|
|
424
|
+
font-weight: 600;
|
|
425
|
+
line-height: 1.3;
|
|
426
|
+
overflow-wrap: anywhere;
|
|
427
|
+
}
|
|
428
|
+
|
|
429
|
+
&__summary {
|
|
430
|
+
display: -webkit-box;
|
|
431
|
+
-webkit-line-clamp: 2;
|
|
432
|
+
line-clamp: 2;
|
|
433
|
+
-webkit-box-orient: vertical;
|
|
434
|
+
overflow: hidden;
|
|
435
|
+
font-size: 0.8125rem;
|
|
436
|
+
line-height: 1.4;
|
|
437
|
+
color: var(--mg-wn-text-muted);
|
|
438
|
+
}
|
|
439
|
+
}
|
|
440
|
+
|
|
441
|
+
[dir="rtl"] .mg-wn-drawer {
|
|
442
|
+
animation-name: mg-wn-drawer-in-rtl;
|
|
443
|
+
}
|
|
444
|
+
|
|
445
|
+
@keyframes mg-wn-drawer-in {
|
|
446
|
+
from {
|
|
447
|
+
transform: translateX(100%);
|
|
448
|
+
}
|
|
449
|
+
to {
|
|
450
|
+
transform: translateX(0);
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
@keyframes mg-wn-drawer-in-rtl {
|
|
455
|
+
from {
|
|
456
|
+
transform: translateX(-100%);
|
|
457
|
+
}
|
|
458
|
+
to {
|
|
459
|
+
transform: translateX(0);
|
|
460
|
+
}
|
|
461
|
+
}
|
|
462
|
+
|
|
463
|
+
@media (prefers-reduced-motion: reduce) {
|
|
464
|
+
.mg-wn-drawer {
|
|
465
|
+
animation: none;
|
|
466
|
+
}
|
|
467
|
+
}
|
|
468
|
+
</style>
|
|
@@ -0,0 +1,120 @@
|
|
|
1
|
+
<script setup lang="ts">
|
|
2
|
+
/**
|
|
3
|
+
* Host of the "Novidades" history: the side drawer and the announcement dialog reopened from it. Mounted once by
|
|
4
|
+
* <MgHeaderComponent /> (outside the user dropdown, which unmounts when it closes) so both survive the menu.
|
|
5
|
+
* Also loads the unread number for the badge, once per login identity.
|
|
6
|
+
*
|
|
7
|
+
* Off with `mgSharedUi.whatsNew.history: false` (or `whatsNew.enabled: false`); the backend decides the content.
|
|
8
|
+
*/
|
|
9
|
+
import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
|
|
10
|
+
import { storeToRefs } from "pinia";
|
|
11
|
+
import type { WnHistoryItem } from "../../utils/whatsNew";
|
|
12
|
+
|
|
13
|
+
const store = useWhatsNewStore();
|
|
14
|
+
const authStore = useAuthStore();
|
|
15
|
+
const { user, signedIn } = storeToRefs(authStore);
|
|
16
|
+
const router = useRouter();
|
|
17
|
+
|
|
18
|
+
const i18nLocale = (() => {
|
|
19
|
+
try {
|
|
20
|
+
return useI18n().locale;
|
|
21
|
+
} catch {
|
|
22
|
+
return ref("en");
|
|
23
|
+
}
|
|
24
|
+
})();
|
|
25
|
+
const localePath: ((p: string) => string) | null = (() => {
|
|
26
|
+
try {
|
|
27
|
+
return useLocalePath() as any;
|
|
28
|
+
} catch {
|
|
29
|
+
return null;
|
|
30
|
+
}
|
|
31
|
+
})();
|
|
32
|
+
|
|
33
|
+
const shared: any = useRuntimeConfig().public.mgSharedUi ?? {};
|
|
34
|
+
const cfg: any = shared.whatsNew ?? {};
|
|
35
|
+
// Same two values the store needs to call the API: without them there is nothing to open, so no entry is offered.
|
|
36
|
+
const configured = !!(shared.networkBaseUrl || import.meta.env.VITE_BASE_URL_NETWORK) && !!(shared.systemId || import.meta.env.VITE_SYSTEM_ID);
|
|
37
|
+
const enabled = cfg.enabled !== false && cfg.history !== false && configured;
|
|
38
|
+
const uiLocale = computed(() => i18nLocale.value || "en");
|
|
39
|
+
const identity = computed(() => (signedIn.value ? String(user.value?.uuid ?? user.value?.id ?? "user") : null));
|
|
40
|
+
|
|
41
|
+
onMounted(() => {
|
|
42
|
+
if (!enabled) return;
|
|
43
|
+
store.hostMounted = true;
|
|
44
|
+
if (identity.value) store.fetchUnread(identity.value);
|
|
45
|
+
});
|
|
46
|
+
|
|
47
|
+
onBeforeUnmount(() => {
|
|
48
|
+
store.hostMounted = false;
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
watch(identity, (id) => {
|
|
52
|
+
if (!enabled) return;
|
|
53
|
+
if (id) store.fetchUnread(id);
|
|
54
|
+
else store.resetHistory();
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
/** In-app path → final route, or null when this front has no such route (the link then renders as text). */
|
|
58
|
+
function resolveInternal(path: string): string | null {
|
|
59
|
+
if (!path.startsWith("/") || path.startsWith("//")) return null;
|
|
60
|
+
const target = localePath ? localePath(path) : path;
|
|
61
|
+
try {
|
|
62
|
+
const resolved = router.resolve(target);
|
|
63
|
+
const real = resolved.matched.some((m) => !/\(\.\*\)|:pathMatch|\*\*/.test(m.path));
|
|
64
|
+
return real ? target : null;
|
|
65
|
+
} catch {
|
|
66
|
+
return null;
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
function onOpen(item: WnHistoryItem) {
|
|
71
|
+
void store.openItem(item, uiLocale.value);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
// ── the reopened announcement (same dialog as the modal) ───────────────────
|
|
75
|
+
function onCta() {
|
|
76
|
+
if (store.viewing) store.trackFor(store.viewing, "cta_click");
|
|
77
|
+
store.closeViewing();
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
function onNavigate(path: string) {
|
|
81
|
+
// A link click is neither "seen" nor "dismissed": get out of the way and go.
|
|
82
|
+
store.closeViewing(false);
|
|
83
|
+
store.closeDrawer();
|
|
84
|
+
router.push(path);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
function onLink(target: string) {
|
|
88
|
+
if (store.viewing) store.trackFor(store.viewing, "link_click", target);
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
function onVideoPlay() {
|
|
92
|
+
if (store.viewing) store.trackFor(store.viewing, "video_play");
|
|
93
|
+
}
|
|
94
|
+
</script>
|
|
95
|
+
|
|
96
|
+
<template>
|
|
97
|
+
<ClientOnly>
|
|
98
|
+
<Teleport to="body">
|
|
99
|
+
<MgWhatsNewDrawer
|
|
100
|
+
v-if="enabled && signedIn && store.drawerOpen"
|
|
101
|
+
:locale="uiLocale"
|
|
102
|
+
@close="store.closeDrawer()"
|
|
103
|
+
@open="onOpen"
|
|
104
|
+
@more="store.loadMoreHistory(uiLocale)"
|
|
105
|
+
@retry="store.fetchHistory(uiLocale, 1)"
|
|
106
|
+
/>
|
|
107
|
+
<MgWhatsNewDialog
|
|
108
|
+
v-if="enabled && signedIn && store.viewing"
|
|
109
|
+
:post="store.viewing"
|
|
110
|
+
:locale="uiLocale"
|
|
111
|
+
:resolve-internal="resolveInternal"
|
|
112
|
+
@close="store.closeViewing()"
|
|
113
|
+
@cta="onCta"
|
|
114
|
+
@navigate="onNavigate"
|
|
115
|
+
@link="onLink"
|
|
116
|
+
@video-play="onVideoPlay"
|
|
117
|
+
/>
|
|
118
|
+
</Teleport>
|
|
119
|
+
</ClientOnly>
|
|
120
|
+
</template>
|
|
@@ -0,0 +1,92 @@
|
|
|
1
|
+
<script setup lang="ts">
|
|
2
|
+
/**
|
|
3
|
+
* "Novidades" entry of the user menu: opens the history drawer and shows how many announcements the
|
|
4
|
+
* user has not seen yet. The drawer itself lives in <MgWhatsNewHistory /> (mounted by the header, outside the
|
|
5
|
+
* dropdown, so it survives the menu closing).
|
|
6
|
+
*/
|
|
7
|
+
import { computed } from "vue";
|
|
8
|
+
import { formatBadge } from "../../utils/whatsNew";
|
|
9
|
+
import { wnText } from "../../utils/whatsNewText";
|
|
10
|
+
|
|
11
|
+
const emit = defineEmits<{ (e: "opened"): void }>();
|
|
12
|
+
|
|
13
|
+
const store = useWhatsNewStore();
|
|
14
|
+
const { locale } = useI18n();
|
|
15
|
+
|
|
16
|
+
const badge = computed(() => formatBadge(store.unread));
|
|
17
|
+
const label = computed(() => {
|
|
18
|
+
const base = wnText(locale.value, "menu_title");
|
|
19
|
+
return store.unread > 0 ? `${base}, ${store.unread} ${wnText(locale.value, "history_unread")}` : base;
|
|
20
|
+
});
|
|
21
|
+
|
|
22
|
+
function open() {
|
|
23
|
+
void store.openDrawer(locale.value);
|
|
24
|
+
emit("opened");
|
|
25
|
+
}
|
|
26
|
+
</script>
|
|
27
|
+
|
|
28
|
+
<template>
|
|
29
|
+
<button type="button" class="mg-wn-menu-item" :aria-label="label" aria-haspopup="dialog" @click="open">
|
|
30
|
+
<span class="mg-wn-menu-item__icon" aria-hidden="true">
|
|
31
|
+
<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="square">
|
|
32
|
+
<path d="M12 3l1.9 5.1L19 10l-5.1 1.9L12 17l-1.9-5.1L5 10l5.1-1.9L12 3z" />
|
|
33
|
+
<path d="M19 16l.8 2.2L22 19l-2.2.8L19 22l-.8-2.2L16 19l2.2-.8L19 16z" />
|
|
34
|
+
</svg>
|
|
35
|
+
</span>
|
|
36
|
+
<span class="mg-wn-menu-item__label">{{ wnText(locale, "menu_title") }}</span>
|
|
37
|
+
<span v-if="badge" class="mg-wn-menu-item__badge" aria-hidden="true">{{ badge }}</span>
|
|
38
|
+
</button>
|
|
39
|
+
</template>
|
|
40
|
+
|
|
41
|
+
<style lang="scss" scoped>
|
|
42
|
+
.mg-wn-menu-item {
|
|
43
|
+
display: flex;
|
|
44
|
+
align-items: center;
|
|
45
|
+
gap: 8px;
|
|
46
|
+
width: 100%;
|
|
47
|
+
padding: 6px 0;
|
|
48
|
+
font: inherit;
|
|
49
|
+
font-size: 0.8125rem;
|
|
50
|
+
text-align: start;
|
|
51
|
+
color: var(--secondary-info-fg, var(--inactive));
|
|
52
|
+
background: transparent;
|
|
53
|
+
border: 0;
|
|
54
|
+
cursor: pointer;
|
|
55
|
+
|
|
56
|
+
&:hover,
|
|
57
|
+
&:focus-visible {
|
|
58
|
+
color: var(--active);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
&:focus-visible {
|
|
62
|
+
outline: 2px solid var(--mg-wn-accent);
|
|
63
|
+
outline-offset: 2px;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
&__icon {
|
|
67
|
+
display: inline-flex;
|
|
68
|
+
flex: none;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
&__label {
|
|
72
|
+
flex: 1;
|
|
73
|
+
min-width: 0;
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
&__badge {
|
|
77
|
+
flex: none;
|
|
78
|
+
min-width: 20px;
|
|
79
|
+
height: 20px;
|
|
80
|
+
padding: 0 6px;
|
|
81
|
+
display: inline-flex;
|
|
82
|
+
align-items: center;
|
|
83
|
+
justify-content: center;
|
|
84
|
+
font-size: 0.6875rem;
|
|
85
|
+
font-weight: 700;
|
|
86
|
+
line-height: 1;
|
|
87
|
+
color: var(--mg-wn-on-accent);
|
|
88
|
+
background: var(--mg-wn-accent);
|
|
89
|
+
border-radius: 0;
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
</style>
|
package/nuxt.config.ts
CHANGED
|
@@ -158,8 +158,8 @@ export default defineNuxtConfig({
|
|
|
158
158
|
gamification: true,
|
|
159
159
|
},
|
|
160
160
|
// Presence: pings the API every couple of minutes while a signed-in user has a tab open, so the admin can
|
|
161
|
-
// show who is online and who stopped coming back. Off until a front opts in
|
|
162
|
-
//
|
|
161
|
+
// show who is online and who stopped coming back. Off until a front opts in; the platform is the front's VITE_SYSTEM_ID.
|
|
162
|
+
// Turn on, no rebuild needed: NUXT_PUBLIC_MG_SHARED_UI_PRESENCE_ENABLED=true.
|
|
163
163
|
presence: {
|
|
164
164
|
enabled: false,
|
|
165
165
|
intervalSeconds: 120, // never below 60
|
|
@@ -170,6 +170,8 @@ export default defineNuxtConfig({
|
|
|
170
170
|
// (login, signup, checkout, payment, create/publish/upload...).
|
|
171
171
|
whatsNew: {
|
|
172
172
|
enabled: true,
|
|
173
|
+
// "Novidades" entry in the user menu + side drawer with the past announcements (needs a signed-in user).
|
|
174
|
+
history: true,
|
|
173
175
|
allowedRoutes: [] as string[],
|
|
174
176
|
blockedRoutes: [] as string[],
|
|
175
177
|
},
|
package/package.json
CHANGED
package/stores/whatsNew.ts
CHANGED
|
@@ -1,16 +1,21 @@
|
|
|
1
1
|
import { defineStore } from "pinia";
|
|
2
2
|
import {
|
|
3
|
+
WN_HISTORY_PAGE,
|
|
3
4
|
WN_MAX_BATCH,
|
|
4
5
|
chunkEvents,
|
|
5
6
|
newDeviceId,
|
|
6
7
|
toApiLang,
|
|
7
8
|
type WnEventName,
|
|
9
|
+
type WnHistoryItem,
|
|
10
|
+
type WnHistoryMeta,
|
|
8
11
|
type WnPost,
|
|
9
12
|
type WnReceiptEvent,
|
|
10
13
|
} from "../utils/whatsNew";
|
|
11
14
|
|
|
12
15
|
const DEVICE_KEY = "mg_wn_device_id";
|
|
13
16
|
const LAST_SHOWN_KEY = "mg_wn_last_shown_at";
|
|
17
|
+
/** The list in the drawer is reloaded when it is older than this on open. */
|
|
18
|
+
const HISTORY_STALE_MS = 60_000;
|
|
14
19
|
|
|
15
20
|
function readStorage(key: string): string | null {
|
|
16
21
|
try {
|
|
@@ -59,6 +64,21 @@ export const useWhatsNewStore = defineStore("whats-new-store", {
|
|
|
59
64
|
loading: false,
|
|
60
65
|
shownThisSession: false,
|
|
61
66
|
open: false,
|
|
67
|
+
// ── history (menu entry + side drawer) ──
|
|
68
|
+
unread: 0,
|
|
69
|
+
unreadFor: null as string | null,
|
|
70
|
+
drawerOpen: false,
|
|
71
|
+
// <MgWhatsNewHistory /> is mounted: the menu entry only shows when something can open the drawer.
|
|
72
|
+
hostMounted: false,
|
|
73
|
+
history: [] as WnHistoryItem[],
|
|
74
|
+
historyMeta: null as WnHistoryMeta | null,
|
|
75
|
+
historyStatus: "idle" as "idle" | "loading" | "loadingMore" | "error",
|
|
76
|
+
historyLoadedAt: 0,
|
|
77
|
+
// A post reopened from the history. Separate from `post`, which belongs to the one-per-session queue.
|
|
78
|
+
viewing: null as WnPost | null,
|
|
79
|
+
viewingWasNew: false,
|
|
80
|
+
openingId: null as number | null,
|
|
81
|
+
openError: false,
|
|
62
82
|
}),
|
|
63
83
|
|
|
64
84
|
actions: {
|
|
@@ -108,6 +128,8 @@ export const useWhatsNewStore = defineStore("whats-new-store", {
|
|
|
108
128
|
this.shownThisSession = true;
|
|
109
129
|
writeStorage(LAST_SHOWN_KEY, String(Date.now()));
|
|
110
130
|
this.track("view");
|
|
131
|
+
this.markSeenLocal(this.post.id);
|
|
132
|
+
this.refreshUnreadSoon();
|
|
111
133
|
},
|
|
112
134
|
|
|
113
135
|
hide() {
|
|
@@ -120,15 +142,19 @@ export const useWhatsNewStore = defineStore("whats-new-store", {
|
|
|
120
142
|
this.remaining = 0;
|
|
121
143
|
this.fetchedFor = null;
|
|
122
144
|
this.open = false;
|
|
145
|
+
this.resetHistory();
|
|
123
146
|
},
|
|
124
147
|
|
|
125
148
|
track(event: WnEventName, target?: string) {
|
|
126
|
-
if (
|
|
149
|
+
if (this.post) this.trackFor(this.post, event, target);
|
|
150
|
+
},
|
|
151
|
+
|
|
152
|
+
trackFor(post: WnPost, event: WnEventName, target?: string) {
|
|
127
153
|
const { platformId } = getConfig();
|
|
128
154
|
if (!platformId) return;
|
|
129
155
|
const entry: WnReceiptEvent = {
|
|
130
|
-
post_id:
|
|
131
|
-
post_version:
|
|
156
|
+
post_id: post.id,
|
|
157
|
+
post_version: post.version,
|
|
132
158
|
event,
|
|
133
159
|
platform_id: platformId,
|
|
134
160
|
surface: "web",
|
|
@@ -141,6 +167,154 @@ export const useWhatsNewStore = defineStore("whats-new-store", {
|
|
|
141
167
|
else if (!flushTimer) flushTimer = setTimeout(() => this.flush(), 1500);
|
|
142
168
|
},
|
|
143
169
|
|
|
170
|
+
// ── history ───────────────────────────────────────────────────────────
|
|
171
|
+
|
|
172
|
+
resetHistory() {
|
|
173
|
+
this.unread = 0;
|
|
174
|
+
this.unreadFor = null;
|
|
175
|
+
this.drawerOpen = false;
|
|
176
|
+
this.history = [];
|
|
177
|
+
this.historyMeta = null;
|
|
178
|
+
this.historyStatus = "idle";
|
|
179
|
+
this.historyLoadedAt = 0;
|
|
180
|
+
this.viewing = null;
|
|
181
|
+
this.viewingWasNew = false;
|
|
182
|
+
this.openingId = null;
|
|
183
|
+
this.openError = false;
|
|
184
|
+
},
|
|
185
|
+
|
|
186
|
+
/** Badge number. One light call per login identity; `force` re-reads it (after a view or closing the drawer). */
|
|
187
|
+
async fetchUnread(identity: string, force = false) {
|
|
188
|
+
if (!force && this.unreadFor === identity) return;
|
|
189
|
+
const { networkBaseUrl, platformId } = getConfig();
|
|
190
|
+
if (!networkBaseUrl || !platformId) return;
|
|
191
|
+
this.unreadFor = identity;
|
|
192
|
+
try {
|
|
193
|
+
const params = new URLSearchParams({ platform_id: String(platformId), surface: "web" });
|
|
194
|
+
const res: any = await $fetch(`${networkBaseUrl}/whats-new/unread-count?${params.toString()}`, {
|
|
195
|
+
credentials: "include",
|
|
196
|
+
timeout: 8000,
|
|
197
|
+
retry: 0,
|
|
198
|
+
});
|
|
199
|
+
if (this.unreadFor !== identity) return; // user switched meanwhile
|
|
200
|
+
this.unread = Math.max(0, Number(res?.data?.count ?? 0));
|
|
201
|
+
} catch {
|
|
202
|
+
// Non-critical: no badge is better than a broken menu.
|
|
203
|
+
if (force) return;
|
|
204
|
+
this.unreadFor = null;
|
|
205
|
+
}
|
|
206
|
+
},
|
|
207
|
+
|
|
208
|
+
/** Re-reads the badge a moment after a `view` (the server may have retired older posts too). */
|
|
209
|
+
refreshUnreadSoon() {
|
|
210
|
+
const identity = this.unreadFor;
|
|
211
|
+
if (!identity || typeof window === "undefined") return;
|
|
212
|
+
setTimeout(() => this.fetchUnread(identity, true), 2500);
|
|
213
|
+
},
|
|
214
|
+
|
|
215
|
+
/** The user has just seen post `id`: update the list row and the badge without waiting for the server. */
|
|
216
|
+
markSeenLocal(id: number) {
|
|
217
|
+
const row = this.history.find((h) => h.id === id);
|
|
218
|
+
if (row) {
|
|
219
|
+
if (!row.is_new) return; // already counted
|
|
220
|
+
row.is_new = false;
|
|
221
|
+
row.seen_at = new Date().toISOString();
|
|
222
|
+
}
|
|
223
|
+
this.unread = Math.max(0, this.unread - 1);
|
|
224
|
+
},
|
|
225
|
+
|
|
226
|
+
async fetchHistory(locale: string, page = 1) {
|
|
227
|
+
const { networkBaseUrl, platformId } = getConfig();
|
|
228
|
+
if (!networkBaseUrl || !platformId) return;
|
|
229
|
+
const append = page > 1;
|
|
230
|
+
this.historyStatus = append ? "loadingMore" : "loading";
|
|
231
|
+
try {
|
|
232
|
+
const params = new URLSearchParams({
|
|
233
|
+
platform_id: String(platformId),
|
|
234
|
+
surface: "web",
|
|
235
|
+
lang: toApiLang(locale),
|
|
236
|
+
page: String(page),
|
|
237
|
+
per_page: String(WN_HISTORY_PAGE),
|
|
238
|
+
});
|
|
239
|
+
const res: any = await $fetch(`${networkBaseUrl}/whats-new?${params.toString()}`, {
|
|
240
|
+
credentials: "include",
|
|
241
|
+
timeout: 10000,
|
|
242
|
+
retry: 0,
|
|
243
|
+
});
|
|
244
|
+
const rows: WnHistoryItem[] = Array.isArray(res?.data) ? res.data : [];
|
|
245
|
+
if (append) {
|
|
246
|
+
const known = new Set(this.history.map((h) => h.id));
|
|
247
|
+
this.history = [...this.history, ...rows.filter((r) => !known.has(r.id))];
|
|
248
|
+
} else {
|
|
249
|
+
this.history = rows;
|
|
250
|
+
}
|
|
251
|
+
this.historyMeta = res?.meta ?? null;
|
|
252
|
+
if (this.historyMeta) this.unread = Math.max(0, Number(this.historyMeta.unread_count ?? 0));
|
|
253
|
+
this.historyLoadedAt = Date.now();
|
|
254
|
+
this.historyStatus = "idle";
|
|
255
|
+
} catch {
|
|
256
|
+
this.historyStatus = "error";
|
|
257
|
+
}
|
|
258
|
+
},
|
|
259
|
+
|
|
260
|
+
async openDrawer(locale: string) {
|
|
261
|
+
this.drawerOpen = true;
|
|
262
|
+
this.openError = false;
|
|
263
|
+
const stale = Date.now() - this.historyLoadedAt > HISTORY_STALE_MS;
|
|
264
|
+
if (this.historyStatus === "idle" && (!this.history.length || stale)) await this.fetchHistory(locale, 1);
|
|
265
|
+
else if (this.historyStatus === "error") await this.fetchHistory(locale, 1);
|
|
266
|
+
},
|
|
267
|
+
|
|
268
|
+
closeDrawer() {
|
|
269
|
+
this.drawerOpen = false;
|
|
270
|
+
},
|
|
271
|
+
|
|
272
|
+
async loadMoreHistory(locale: string) {
|
|
273
|
+
const meta = this.historyMeta;
|
|
274
|
+
if (!meta || this.historyStatus !== "idle" || meta.page >= meta.last_page) return;
|
|
275
|
+
await this.fetchHistory(locale, meta.page + 1);
|
|
276
|
+
},
|
|
277
|
+
|
|
278
|
+
/** Reopens one announcement from the list. Only the first time (`is_new`) counts as a `view`. */
|
|
279
|
+
async openItem(item: WnHistoryItem, locale: string) {
|
|
280
|
+
const { networkBaseUrl, platformId } = getConfig();
|
|
281
|
+
if (!networkBaseUrl || !platformId || this.openingId !== null) return;
|
|
282
|
+
this.openingId = item.id;
|
|
283
|
+
this.openError = false;
|
|
284
|
+
try {
|
|
285
|
+
const params = new URLSearchParams({
|
|
286
|
+
platform_id: String(platformId),
|
|
287
|
+
surface: "web",
|
|
288
|
+
lang: toApiLang(locale),
|
|
289
|
+
});
|
|
290
|
+
const res: any = await $fetch(`${networkBaseUrl}/whats-new/${item.id}?${params.toString()}`, {
|
|
291
|
+
credentials: "include",
|
|
292
|
+
timeout: 10000,
|
|
293
|
+
retry: 0,
|
|
294
|
+
});
|
|
295
|
+
if (!res?.data) throw new Error("empty");
|
|
296
|
+
this.viewing = res.data as WnPost;
|
|
297
|
+
this.viewingWasNew = item.is_new;
|
|
298
|
+
if (item.is_new) {
|
|
299
|
+
this.trackFor(this.viewing, "view");
|
|
300
|
+
this.markSeenLocal(item.id);
|
|
301
|
+
this.refreshUnreadSoon();
|
|
302
|
+
}
|
|
303
|
+
} catch {
|
|
304
|
+
this.openError = true;
|
|
305
|
+
} finally {
|
|
306
|
+
this.openingId = null;
|
|
307
|
+
}
|
|
308
|
+
},
|
|
309
|
+
|
|
310
|
+
/** Closing a reopened announcement. If it was new, the user has now dealt with it: `dismiss`. */
|
|
311
|
+
closeViewing(dismiss = true) {
|
|
312
|
+
if (dismiss && this.viewing && this.viewingWasNew) this.trackFor(this.viewing, "dismiss");
|
|
313
|
+
this.viewing = null;
|
|
314
|
+
this.viewingWasNew = false;
|
|
315
|
+
this.flush();
|
|
316
|
+
},
|
|
317
|
+
|
|
144
318
|
/** Sends queued events in batches of ≤20. keepalive lets it survive a page unload. */
|
|
145
319
|
flush() {
|
|
146
320
|
if (flushTimer) {
|
package/utils/whatsNew.ts
CHANGED
|
@@ -45,6 +45,37 @@ export interface WnPost {
|
|
|
45
45
|
history_url: string | null;
|
|
46
46
|
}
|
|
47
47
|
|
|
48
|
+
/** One row of the history list (GET /whats-new). `is_new` = the user has not seen it yet. */
|
|
49
|
+
export interface WnHistoryItem {
|
|
50
|
+
id: number;
|
|
51
|
+
version: number;
|
|
52
|
+
kind: WnPost["kind"];
|
|
53
|
+
title: string;
|
|
54
|
+
summary: string | null;
|
|
55
|
+
published_at: string | null;
|
|
56
|
+
thumb_url: string | null;
|
|
57
|
+
seen_at: string | null;
|
|
58
|
+
is_new: boolean;
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
export interface WnHistoryMeta {
|
|
62
|
+
total: number;
|
|
63
|
+
page: number;
|
|
64
|
+
per_page: number;
|
|
65
|
+
last_page: number;
|
|
66
|
+
unread_count: number;
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
/** Page size of the drawer list. */
|
|
70
|
+
export const WN_HISTORY_PAGE = 20;
|
|
71
|
+
|
|
72
|
+
/** Badge text: nothing at 0, "9+" from ten up so it never outgrows the menu row. */
|
|
73
|
+
export function formatBadge(count: number | null | undefined): string {
|
|
74
|
+
const n = Math.floor(Number(count) || 0);
|
|
75
|
+
if (n <= 0) return "";
|
|
76
|
+
return n > 9 ? "9+" : String(n);
|
|
77
|
+
}
|
|
78
|
+
|
|
48
79
|
// ─── Inline markup: **bold** and [text](url) ────────────────────────────────
|
|
49
80
|
|
|
50
81
|
/** The single link regex shared with every other client (see the contract). */
|
|
@@ -27,6 +27,18 @@ export const WN_MESSAGES = {
|
|
|
27
27
|
follow: "Follow the network",
|
|
28
28
|
new_tab: "opens in a new tab",
|
|
29
29
|
media_label: "Media",
|
|
30
|
+
menu_title: "What's new",
|
|
31
|
+
history_title: "What's new",
|
|
32
|
+
history_subtitle: "Latest features and improvements",
|
|
33
|
+
history_empty: "Nothing new yet. Come back soon!",
|
|
34
|
+
history_error: "We could not load the news.",
|
|
35
|
+
history_retry: "Try again",
|
|
36
|
+
history_more: "Load more",
|
|
37
|
+
history_new: "New",
|
|
38
|
+
history_open: "Open",
|
|
39
|
+
history_unread: "unread",
|
|
40
|
+
history_loading: "Loading…",
|
|
41
|
+
history_open_error: "We could not open this announcement.",
|
|
30
42
|
},
|
|
31
43
|
"pt-BR": {
|
|
32
44
|
title: "Novidades",
|
|
@@ -47,6 +59,18 @@ export const WN_MESSAGES = {
|
|
|
47
59
|
follow: "Siga a rede",
|
|
48
60
|
new_tab: "abre em uma nova aba",
|
|
49
61
|
media_label: "Mídia",
|
|
62
|
+
menu_title: "Novidades",
|
|
63
|
+
history_title: "Novidades",
|
|
64
|
+
history_subtitle: "Últimos recursos e melhorias",
|
|
65
|
+
history_empty: "Nada de novo por enquanto. Volte logo!",
|
|
66
|
+
history_error: "Não foi possível carregar as novidades.",
|
|
67
|
+
history_retry: "Tentar de novo",
|
|
68
|
+
history_more: "Carregar mais",
|
|
69
|
+
history_new: "Nova",
|
|
70
|
+
history_open: "Abrir",
|
|
71
|
+
history_unread: "não lidas",
|
|
72
|
+
history_loading: "Carregando…",
|
|
73
|
+
history_open_error: "Não foi possível abrir este comunicado.",
|
|
50
74
|
},
|
|
51
75
|
"de": {
|
|
52
76
|
title: "Neuigkeiten",
|
|
@@ -67,6 +91,18 @@ export const WN_MESSAGES = {
|
|
|
67
91
|
follow: "Folge dem Netzwerk",
|
|
68
92
|
new_tab: "öffnet in einem neuen Tab",
|
|
69
93
|
media_label: "Medien",
|
|
94
|
+
menu_title: "Neuigkeiten",
|
|
95
|
+
history_title: "Neuigkeiten",
|
|
96
|
+
history_subtitle: "Neueste Funktionen und Verbesserungen",
|
|
97
|
+
history_empty: "Noch nichts Neues. Schau bald wieder vorbei!",
|
|
98
|
+
history_error: "Die Neuigkeiten konnten nicht geladen werden.",
|
|
99
|
+
history_retry: "Erneut versuchen",
|
|
100
|
+
history_more: "Mehr laden",
|
|
101
|
+
history_new: "Neu",
|
|
102
|
+
history_open: "Öffnen",
|
|
103
|
+
history_unread: "ungelesen",
|
|
104
|
+
history_loading: "Wird geladen…",
|
|
105
|
+
history_open_error: "Diese Mitteilung konnte nicht geöffnet werden.",
|
|
70
106
|
},
|
|
71
107
|
"es": {
|
|
72
108
|
title: "Novedades",
|
|
@@ -87,6 +123,18 @@ export const WN_MESSAGES = {
|
|
|
87
123
|
follow: "Sigue la red",
|
|
88
124
|
new_tab: "se abre en una pestaña nueva",
|
|
89
125
|
media_label: "Multimedia",
|
|
126
|
+
menu_title: "Novedades",
|
|
127
|
+
history_title: "Novedades",
|
|
128
|
+
history_subtitle: "Últimas funciones y mejoras",
|
|
129
|
+
history_empty: "Aún no hay novedades. ¡Vuelve pronto!",
|
|
130
|
+
history_error: "No se pudieron cargar las novedades.",
|
|
131
|
+
history_retry: "Reintentar",
|
|
132
|
+
history_more: "Cargar más",
|
|
133
|
+
history_new: "Nueva",
|
|
134
|
+
history_open: "Abrir",
|
|
135
|
+
history_unread: "sin leer",
|
|
136
|
+
history_loading: "Cargando…",
|
|
137
|
+
history_open_error: "No se pudo abrir este comunicado.",
|
|
90
138
|
},
|
|
91
139
|
"ro": {
|
|
92
140
|
title: "Noutăți",
|
|
@@ -107,6 +155,18 @@ export const WN_MESSAGES = {
|
|
|
107
155
|
follow: "Urmărește rețeaua",
|
|
108
156
|
new_tab: "se deschide într-o filă nouă",
|
|
109
157
|
media_label: "Media",
|
|
158
|
+
menu_title: "Noutăți",
|
|
159
|
+
history_title: "Noutăți",
|
|
160
|
+
history_subtitle: "Cele mai recente funcții și îmbunătățiri",
|
|
161
|
+
history_empty: "Nimic nou deocamdată. Revino curând!",
|
|
162
|
+
history_error: "Noutățile nu au putut fi încărcate.",
|
|
163
|
+
history_retry: "Încearcă din nou",
|
|
164
|
+
history_more: "Încarcă mai multe",
|
|
165
|
+
history_new: "Nou",
|
|
166
|
+
history_open: "Deschide",
|
|
167
|
+
history_unread: "necitite",
|
|
168
|
+
history_loading: "Se încarcă…",
|
|
169
|
+
history_open_error: "Acest anunț nu a putut fi deschis.",
|
|
110
170
|
},
|
|
111
171
|
"ar": {
|
|
112
172
|
title: "الجديد",
|
|
@@ -127,6 +187,18 @@ export const WN_MESSAGES = {
|
|
|
127
187
|
follow: "تابع الشبكة",
|
|
128
188
|
new_tab: "يفتح في علامة تبويب جديدة",
|
|
129
189
|
media_label: "وسائط",
|
|
190
|
+
menu_title: "الجديد",
|
|
191
|
+
history_title: "الجديد",
|
|
192
|
+
history_subtitle: "أحدث الميزات والتحسينات",
|
|
193
|
+
history_empty: "لا جديد بعد. عد قريبًا!",
|
|
194
|
+
history_error: "تعذّر تحميل الأخبار.",
|
|
195
|
+
history_retry: "حاول مرة أخرى",
|
|
196
|
+
history_more: "تحميل المزيد",
|
|
197
|
+
history_new: "جديد",
|
|
198
|
+
history_open: "فتح",
|
|
199
|
+
history_unread: "غير مقروءة",
|
|
200
|
+
history_loading: "جارٍ التحميل…",
|
|
201
|
+
history_open_error: "تعذّر فتح هذا الإعلان.",
|
|
130
202
|
},
|
|
131
203
|
} as const;
|
|
132
204
|
|