@@ -8873,73 +9188,151 @@
`;
}).join('');
- attachInstructionConnectHandlers(container);
+ attachInstructionConnectHandlers(container, apps);
updateInstructionConnectButtons(hasConnectLink);
}
- function renderAppSteps(app) {
- let html = '';
- let stepNum = 1;
-
- if (app.installationStep) {
- const descriptionHtml = app.installationStep.description
- ? `
${getLocalizedText(app.installationStep.description)}
`
- : '';
- const buttonsHtml = Array.isArray(app.installationStep.buttons) && app.installationStep.buttons.length
- ? `
-
- `
- : '';
- html += `
-
-
${stepNum++}
-
-
${escapeHtml(t('apps.step.download'))}
- ${descriptionHtml}
- ${buttonsHtml}
-
-
- `;
+ function renderInstructionStep(step, options = {}) {
+ if (!step) {
+ return '';
}
- if (app.addSubscriptionStep) {
- html += `
-
-
${stepNum++}
-
-
${escapeHtml(t('apps.step.add'))}
-
${getLocalizedText(app.addSubscriptionStep.description)}
-
-
- `;
+ const {
+ number = null,
+ defaultTitleKey = '',
+ defaultTitle = '',
+ } = options;
+
+ let title = '';
+ let explicitTitle = '';
+ if (Object.prototype.hasOwnProperty.call(step, 'title')) {
+ title = getLocalizedText(step.title);
+ explicitTitle = title;
}
- if (app.connectAndUseStep) {
- html += `
-
-
${stepNum++}
-
-
${escapeHtml(t('apps.step.connect'))}
-
${getLocalizedText(app.connectAndUseStep.description)}
-
-
- `;
+ if (!title) {
+ if (defaultTitleKey) {
+ const translated = t(defaultTitleKey);
+ title = translated && translated !== defaultTitleKey
+ ? translated
+ : (defaultTitle || '');
+ } else {
+ title = defaultTitle || '';
+ }
}
- html += renderConnectActionButton(app.id || '');
+ const description = Object.prototype.hasOwnProperty.call(step, 'description')
+ ? getLocalizedText(step.description)
+ : '';
- return html;
+ const buttons = Array.isArray(step.buttons)
+ ? step.buttons.filter(btn => btn && btn.buttonLink)
+ : [];
+
+ const buttonsHtml = buttons.length
+ ? `
+
+ `
+ : '';
+
+ const hasExplicitTitle = Boolean(explicitTitle);
+ const hasContent = Boolean(description || buttonsHtml.trim().length || hasExplicitTitle);
+ if (!hasContent) {
+ return '';
+ }
+
+ const titleHtml = title ? `
${escapeHtml(title)}
` : '';
+ const descriptionHtml = description
+ ? `
${description}
`
+ : '';
+
+ const stepNumber = Number.isFinite(number) ? Number(number) : null;
+ const numberHtml = stepNumber !== null
+ ? `
${stepNumber}`
+ : '
';
+
+ return `
+
+ ${numberHtml}
+
+ ${titleHtml}
+ ${descriptionHtml}
+ ${buttonsHtml}
+
+
+ `;
}
- function updateInstructionConnectButtons(hasConnect = Boolean(getConnectLink())) {
+ function renderAppSteps(app) {
+ const parts = [];
+ let stepNum = 1;
+
+ function appendStep(step, defaults) {
+ const stepHtml = renderInstructionStep(step, {
+ number: stepNum,
+ ...(defaults || {}),
+ });
+ if (stepHtml) {
+ parts.push(stepHtml);
+ stepNum += 1;
+ }
+ }
+
+ appendStep(app.installationStep, {
+ defaultTitleKey: 'apps.step.download',
+ defaultTitle: 'Download & install',
+ });
+
+ appendStep(app.additionalBeforeAddSubscriptionStep, {
+ defaultTitleKey: 'apps.step.before_add',
+ defaultTitle: 'Before adding subscription',
+ });
+
+ appendStep(app.addSubscriptionStep, {
+ defaultTitleKey: 'apps.step.add',
+ defaultTitle: 'Add subscription',
+ });
+
+ appendStep(app.additionalAfterAddSubscriptionStep, {
+ defaultTitleKey: 'apps.step.after_add',
+ defaultTitle: 'If the subscription is not added',
+ });
+
+ appendStep(app.connectAndUseStep, {
+ defaultTitleKey: 'apps.step.connect',
+ defaultTitle: 'Connect & use',
+ });
+
+ parts.push(renderConnectActionButton(app.id || ''));
+
+ return parts.join('');
+ }
+
+ function updateInstructionConnectButtons(isEnabled = true) {
+ const apps = getAppsForCurrentPlatform();
+
document.querySelectorAll('.step-final-button').forEach(button => {
- button.disabled = !hasConnect;
+ if (!isEnabled) {
+ button.disabled = true;
+ return;
+ }
+
+ const appId = button.getAttribute('data-app-id') || null;
+ const hasLink = Boolean(getConnectLink(appId, { apps }));
+ button.disabled = !hasLink;
});
}
@@ -8951,7 +9344,7 @@
renderApps();
setActivePlatformButton();
- updateInstructionConnectButtons(Boolean(getConnectLink()));
+ updateInstructionConnectButtons(hasAnyConnectLink());
modal.classList.remove('hidden');
document.body.classList.add('modal-open');
@@ -8976,38 +9369,83 @@
document.body.classList.remove('modal-open');
}
+ function normalizeLocalizedValue(value) {
+ if (typeof value !== 'string') {
+ return '';
+ }
+
+ const trimmed = value.trim();
+ if (!trimmed || /^[-–—]+$/.test(trimmed)) {
+ return '';
+ }
+
+ return trimmed;
+ }
+
function getLocalizedText(textObj) {
if (!textObj) {
return '';
}
if (typeof textObj === 'string') {
- return textObj;
+ return normalizeLocalizedValue(textObj);
}
const telegramLang = tg.initDataUnsafe?.user?.language_code;
+ const fallbackLanguages = getSupportedLanguages();
const preferenceOrder = [
preferredLanguage,
preferredLanguage?.split('-')[0],
userData?.user?.language,
telegramLang,
telegramLang?.split('-')[0],
+ ...fallbackLanguages,
'en',
'ru'
].filter(Boolean).map(lang => lang.toLowerCase());
const seen = new Set();
for (const lang of preferenceOrder) {
- if (seen.has(lang)) {
+ const normalizedLang = lang.toLowerCase();
+ if (seen.has(normalizedLang)) {
continue;
}
- seen.add(lang);
- if (textObj[lang]) {
- return textObj[lang];
+ seen.add(normalizedLang);
+
+ const candidateKeys = [normalizedLang];
+ if (lang !== normalizedLang) {
+ candidateKeys.push(lang);
+ }
+
+ for (const key of candidateKeys) {
+ if (!Object.prototype.hasOwnProperty.call(textObj, key)) {
+ continue;
+ }
+ const value = normalizeLocalizedValue(textObj[key]);
+ if (value) {
+ return value;
+ }
}
}
- const fallback = Object.values(textObj).find(value => typeof value === 'string' && value.trim().length);
- return fallback || '';
+ const fallbackKeys = ['default', 'en', 'ru'];
+ for (const key of fallbackKeys) {
+ if (!Object.prototype.hasOwnProperty.call(textObj, key)) {
+ continue;
+ }
+ const value = normalizeLocalizedValue(textObj[key]);
+ if (value) {
+ return value;
+ }
+ }
+
+ for (const value of Object.values(textObj)) {
+ const normalizedValue = normalizeLocalizedValue(value);
+ if (normalizedValue) {
+ return normalizedValue;
+ }
+ }
+
+ return '';
}
function ensureArray(value) {
@@ -9060,6 +9498,186 @@
return fallback;
}
+ function sanitizeAppsConfig(rawPlatforms) {
+ const sanitized = {};
+ if (!rawPlatforms || typeof rawPlatforms !== 'object') {
+ return sanitized;
+ }
+
+ Object.entries(rawPlatforms).forEach(([platformKey, apps]) => {
+ if (!Array.isArray(apps)) {
+ sanitized[platformKey] = [];
+ return;
+ }
+
+ const normalizedApps = apps
+ .map(app => sanitizeAppDefinition(app))
+ .filter(Boolean);
+ sanitized[platformKey] = normalizedApps;
+ });
+
+ return sanitized;
+ }
+
+ function sanitizeAppDefinition(app) {
+ if (!app || typeof app !== 'object') {
+ return null;
+ }
+
+ const sanitized = {};
+
+ const rawId = app.id ?? app.appId ?? app.slug ?? null;
+ let normalizedId = typeof rawId === 'string' && rawId.trim().length
+ ? rawId.trim()
+ : null;
+
+ let resolvedName = '';
+ if (typeof app.name === 'string') {
+ resolvedName = normalizeLocalizedValue(app.name) || app.name;
+ } else if (app.name && typeof app.name === 'object') {
+ const nameCandidates = [
+ app.name.en,
+ app.name.default,
+ app.name.ru,
+ ...Object.values(app.name)
+ ];
+ for (const candidate of nameCandidates) {
+ const normalizedCandidate = normalizeLocalizedValue(candidate);
+ if (normalizedCandidate) {
+ resolvedName = normalizedCandidate;
+ break;
+ }
+ }
+ }
+
+ if (!resolvedName && typeof rawId === 'string') {
+ resolvedName = rawId.trim();
+ }
+
+ if (!normalizedId && resolvedName) {
+ const slug = resolvedName
+ .toLowerCase()
+ .replace(/[^a-z0-9]+/g, '-')
+ .replace(/^-+|-+$/g, '');
+ normalizedId = slug || null;
+ }
+
+ sanitized.id = normalizedId;
+ sanitized.name = resolvedName || 'App';
+
+ const rawScheme = app.urlScheme ?? app.url_scheme ?? '';
+ sanitized.urlScheme = typeof rawScheme === 'string' && rawScheme.trim().length
+ ? rawScheme.trim()
+ : null;
+
+ sanitized.isFeatured = coerceBoolean(app.isFeatured ?? app.is_featured, false);
+ sanitized.isNeedBase64Encoding = coerceBoolean(
+ app.isNeedBase64Encoding ?? app.is_need_base64_encoding,
+ false
+ );
+
+ const installationStep = sanitizeStep(app.installationStep ?? app.installation_step);
+ if (installationStep) {
+ sanitized.installationStep = installationStep;
+ }
+
+ const beforeAddStep = sanitizeStep(
+ app.additionalBeforeAddSubscriptionStep
+ ?? app.additional_before_add_subscription_step
+ );
+ if (beforeAddStep) {
+ sanitized.additionalBeforeAddSubscriptionStep = beforeAddStep;
+ }
+
+ const addStep = sanitizeStep(app.addSubscriptionStep ?? app.add_subscription_step);
+ if (addStep) {
+ sanitized.addSubscriptionStep = addStep;
+ }
+
+ const afterAddStep = sanitizeStep(
+ app.additionalAfterAddSubscriptionStep
+ ?? app.additional_after_add_subscription_step
+ );
+ if (afterAddStep) {
+ sanitized.additionalAfterAddSubscriptionStep = afterAddStep;
+ }
+
+ const connectStep = sanitizeStep(app.connectAndUseStep ?? app.connect_and_use_step);
+ if (connectStep) {
+ sanitized.connectAndUseStep = connectStep;
+ }
+
+ return sanitized;
+ }
+
+ function sanitizeStep(step) {
+ if (!step || typeof step !== 'object') {
+ return null;
+ }
+
+ const sanitized = {};
+
+ if (Object.prototype.hasOwnProperty.call(step, 'title')) {
+ sanitized.title = step.title;
+ }
+
+ if (Object.prototype.hasOwnProperty.call(step, 'description')) {
+ sanitized.description = step.description;
+ }
+
+ const rawButtons = ensureArray(step.buttons ?? step.buttonList ?? step.button_list);
+ const buttons = rawButtons.map(sanitizeButton).filter(Boolean);
+ if (buttons.length) {
+ sanitized.buttons = buttons;
+ }
+
+ if (
+ !Object.prototype.hasOwnProperty.call(sanitized, 'title')
+ && !Object.prototype.hasOwnProperty.call(sanitized, 'description')
+ && !sanitized.buttons
+ ) {
+ return null;
+ }
+
+ return sanitized;
+ }
+
+ function sanitizeButton(button) {
+ if (!button || typeof button !== 'object') {
+ return null;
+ }
+
+ const link = normalizeUrl(
+ button.buttonLink
+ ?? button.button_link
+ ?? button.link
+ ?? button.url
+ ?? button.href
+ );
+
+ if (!link) {
+ return null;
+ }
+
+ const rawText = button.buttonText
+ ?? button.button_text
+ ?? button.text
+ ?? button.label
+ ?? '';
+
+ if (typeof rawText === 'string') {
+ return {
+ buttonLink: link,
+ buttonText: normalizeLocalizedValue(rawText) || rawText,
+ };
+ }
+
+ return {
+ buttonLink: link,
+ buttonText: rawText,
+ };
+ }
+
async function parseJsonSafe(response) {
try {
return await response.json();
@@ -16888,63 +17506,335 @@
return userData?.subscription_url || userData?.subscriptionUrl || '';
}
- function getHappCryptoLink() {
- if (!userData) {
+ function getHappCryptoLink(data = userData) {
+ if (!data || typeof data !== 'object') {
return null;
}
- return (
- userData.happ_crypto_link ||
- userData.subscriptionCryptoLink ||
- userData.subscription_crypto_link ||
- null
- );
+ const happData = data.happ && typeof data.happ === 'object'
+ ? data.happ
+ : null;
+
+ const candidates = [
+ data.happ_crypto_link,
+ data.happCryptoLink,
+ happData?.cryptoLink,
+ happData?.crypto_link,
+ happData?.crypto?.link,
+ happData?.links?.crypto,
+ data.subscriptionCryptoLink,
+ data.subscription_crypto_link,
+ ];
+
+ for (const candidate of candidates) {
+ const normalized = normalizeUrl(candidate);
+ if (normalized) {
+ return normalized;
+ }
+ }
+
+ return null;
}
- function getConnectLink() {
+ function getHappCryptolinkRedirectTemplate(data = userData) {
+ if (typeof cachedHappCryptolinkRedirectTemplate !== 'undefined') {
+ return cachedHappCryptolinkRedirectTemplate || null;
+ }
+
+ const candidates = [];
+
+ if (data && typeof data === 'object') {
+ candidates.push(
+ data.happ_cryptolink_redirect_template,
+ data.happCryptolinkRedirectTemplate,
+ );
+
+ const happData = data.happ && typeof data.happ === 'object'
+ ? data.happ
+ : null;
+
+ if (happData) {
+ candidates.push(
+ happData.cryptolinkRedirectTemplate,
+ happData.cryptolink_redirect_template,
+ happData.redirectTemplate,
+ happData.redirect_template,
+ happData.cryptolink?.redirectTemplate,
+ happData.cryptolink?.redirect_template,
+ );
+ }
+ }
+
+ if (typeof window !== 'undefined') {
+ candidates.push(
+ window.HAPP_CRYPTOLINK_REDIRECT_TEMPLATE,
+ window.happCryptolinkRedirectTemplate,
+ window.__HAPP_CRYPTOLINK_REDIRECT_TEMPLATE__,
+ );
+ }
+
+ for (const candidate of candidates) {
+ const normalized = normalizeUrl(candidate);
+ if (normalized) {
+ cachedHappCryptolinkRedirectTemplate = normalized;
+ return normalized;
+ }
+ }
+
+ cachedHappCryptolinkRedirectTemplate = null;
+ return null;
+ }
+
+ function buildHappCryptolinkRedirectLink(targetLink, template = null) {
+ const normalizedTarget = normalizeUrl(targetLink);
+ const normalizedTemplate = normalizeUrl(template);
+
+ if (!normalizedTarget || !normalizedTemplate) {
+ return null;
+ }
+
+ const encodedTarget = encodeURIComponent(normalizedTarget);
+ let result = normalizedTemplate;
+ let replaced = false;
+
+ const replacements = [
+ ['{subscription_link}', encodedTarget],
+ ['{link}', encodedTarget],
+ ['{subscription_link_raw}', normalizedTarget],
+ ['{link_raw}', normalizedTarget],
+ ];
+
+ for (const [placeholder, replacement] of replacements) {
+ if (result.includes(placeholder)) {
+ result = result.split(placeholder).join(replacement);
+ replaced = true;
+ }
+ }
+
+ if (!replaced) {
+ if (/[?&=]$/.test(result)) {
+ result = `${result}${encodedTarget}`;
+ } else {
+ result = `${result}${encodedTarget}`;
+ }
+ }
+
+ return normalizeUrl(result);
+ }
+
+ function encodeToBase64(value) {
+ if (typeof value !== 'string') {
+ return '';
+ }
+
+ try {
+ return btoa(value);
+ } catch (error) {
+ try {
+ return btoa(encodeURIComponent(value).replace(/%([0-9A-F]{2})/g, (_, p1) => String.fromCharCode(parseInt(p1, 16))));
+ } catch (nestedError) {
+ console.warn('Failed to base64 encode value:', nestedError);
+ return value;
+ }
+ }
+ }
+
+ function buildAppSchemeLink(app, subscriptionUrl) {
+ if (!app || !subscriptionUrl) {
+ return null;
+ }
+
+ const scheme = typeof app.urlScheme === 'string' ? app.urlScheme.trim() : '';
+ if (!scheme) {
+ return null;
+ }
+
+ let payload = subscriptionUrl;
+ if (app.isNeedBase64Encoding) {
+ const encoded = encodeToBase64(subscriptionUrl);
+ payload = encoded || subscriptionUrl;
+ }
+
+ return `${scheme}${payload}`;
+ }
+
+ function getConnectLink(appId = null, options = {}) {
if (!userData) {
return null;
}
+ const apps = Array.isArray(options.apps)
+ ? options.apps
+ : getAppsForCurrentPlatform();
+ const normalizedAppId = typeof appId === 'string' && appId.trim().length
+ ? appId.trim()
+ : null;
+ const requestedApp = normalizedAppId
+ ? apps.find(app => (app.id || '').toString() === normalizedAppId)
+ : null;
+ const featuredApp = apps.find(app => coerceBoolean(app.isFeatured, false)) || apps[0] || null;
+ const selectedApp = requestedApp || featuredApp || null;
+ const selectedAppId = selectedApp?.id != null
+ ? String(selectedApp.id).trim().toLowerCase()
+ : null;
+ const isHappApp = selectedAppId ? HAPP_APP_IDS.has(selectedAppId) : false;
+
+ const subscriptionUrl = normalizeUrl(getCurrentSubscriptionUrl());
+ const subscriptionCryptoLink = normalizeUrl(
+ userData?.subscription_crypto_link
+ || userData?.subscriptionCryptoLink
+ || null
+ );
const happCryptoLink = getHappCryptoLink();
- const isPC = currentPlatform === 'pc' || (!['ios', 'android', 'tv'].includes(currentPlatform));
-
- // For PC, prefer direct subscription URL if no Happ redirect link
- if (isPC) {
- if (userData.happ_cryptolink_redirect_link) {
- return userData.happ_cryptolink_redirect_link;
+ const happData = userData?.happ && typeof userData.happ === 'object'
+ ? userData.happ
+ : null;
+ const redirectLinkRaw = normalizeUrl(
+ userData?.happ_cryptolink_redirect_link
+ || userData?.happCryptolinkRedirectLink
+ || happData?.cryptolinkRedirectLink
+ || happData?.cryptolink_redirect_link
+ || happData?.redirectLink
+ || happData?.redirect_link
+ || null
+ );
+ const happLink = normalizeUrl(
+ userData?.happ_link
+ || userData?.happLink
+ || happData?.link
+ || happData?.appLink
+ || happData?.url
+ || null
+ );
+
+ const schemeLink = selectedApp && subscriptionUrl
+ ? buildAppSchemeLink(selectedApp, subscriptionUrl)
+ : null;
+
+ const detectedPlatform = typeof detectedDevicePlatform === 'string'
+ ? detectedDevicePlatform
+ : currentPlatform;
+ const normalizedDevicePlatform = typeof detectedPlatform === 'string'
+ ? detectedPlatform.toLowerCase()
+ : 'android';
+ const isPCDevice = normalizedDevicePlatform === 'pc';
+ const isMobileDevice = normalizedDevicePlatform === 'ios' || normalizedDevicePlatform === 'android';
+
+ const redirectTemplate = getHappCryptolinkRedirectTemplate();
+ const redirectTarget = (() => {
+ if (isPCDevice) {
+ if (isHappApp) {
+ return (
+ happCryptoLink
+ || subscriptionCryptoLink
+ || subscriptionUrl
+ || happLink
+ || redirectLinkRaw
+ || schemeLink
+ );
+ }
+
+ return (
+ schemeLink
+ || subscriptionUrl
+ || subscriptionCryptoLink
+ || redirectLinkRaw
+ || happCryptoLink
+ || happLink
+ );
}
- if (happCryptoLink) {
- return happCryptoLink;
+
+ if (isHappApp) {
+ return (
+ happCryptoLink
+ || subscriptionCryptoLink
+ || subscriptionUrl
+ || happLink
+ || schemeLink
+ );
+ }
+
+ return (
+ schemeLink
+ || subscriptionUrl
+ || subscriptionCryptoLink
+ || happCryptoLink
+ || happLink
+ );
+ })();
+ const templatedRedirectLink = redirectTemplate
+ ? buildHappCryptolinkRedirectLink(redirectTarget, redirectTemplate)
+ : null;
+
+ const candidates = [];
+ const seen = new Set();
+ const pushCandidate = value => {
+ const normalized = normalizeUrl(value);
+ if (!normalized || seen.has(normalized)) {
+ return;
+ }
+ seen.add(normalized);
+ candidates.push(normalized);
+ };
+
+ if (isPCDevice) {
+ pushCandidate(templatedRedirectLink);
+ if (isHappApp) {
+ pushCandidate(redirectLinkRaw);
+ pushCandidate(happCryptoLink);
+ pushCandidate(happLink);
+ pushCandidate(subscriptionCryptoLink);
+ pushCandidate(subscriptionUrl);
+ } else {
+ pushCandidate(redirectLinkRaw);
+ pushCandidate(subscriptionUrl);
+ pushCandidate(subscriptionCryptoLink);
+ pushCandidate(schemeLink);
+ pushCandidate(happCryptoLink);
+ pushCandidate(happLink);
+ }
+ } else {
+ if (isHappApp) {
+ pushCandidate(happCryptoLink);
+ pushCandidate(happLink);
+ pushCandidate(subscriptionCryptoLink);
+ pushCandidate(subscriptionUrl);
+ } else {
+ pushCandidate(schemeLink);
+ pushCandidate(subscriptionUrl);
+ pushCandidate(subscriptionCryptoLink);
+ }
+
+ if (!isMobileDevice) {
+ pushCandidate(templatedRedirectLink);
+ if (isHappApp) {
+ pushCandidate(redirectLinkRaw);
+ }
}
- // Return plain subscription URL for PC
- return getCurrentSubscriptionUrl();
- }
-
- // Original logic for mobile platforms
- if (happCryptoLink) {
- return happCryptoLink;
}
- if (userData.happ_cryptolink_redirect_link) {
- return userData.happ_cryptolink_redirect_link;
+ pushCandidate(subscriptionUrl);
+ pushCandidate(subscriptionCryptoLink);
+ if (isHappApp) {
+ pushCandidate(happCryptoLink);
+ pushCandidate(happLink);
+ } else {
+ pushCandidate(schemeLink);
}
- const subscriptionUrl = getCurrentSubscriptionUrl();
- if (!subscriptionUrl) {
- return null;
+ return candidates[0] || null;
+ }
+
+ function hasAnyConnectLink(precomputedApps = null) {
+ const apps = Array.isArray(precomputedApps)
+ ? precomputedApps
+ : getAppsForCurrentPlatform();
+
+ if (Boolean(getConnectLink(null, { apps }))) {
+ return true;
}
- const apps = getAppsForCurrentPlatform();
- const featuredApp = apps.find(app => app.isFeatured) || apps[0];
-
- if (featuredApp?.urlScheme) {
- return `${featuredApp.urlScheme}${subscriptionUrl}`;
- }
- if (userData?.happ_link && featuredApp?.id === 'happ') {
- return userData.happ_link;
- }
- return subscriptionUrl;
+ return apps.some(app => Boolean(getConnectLink(app.id || null, { apps })));
}
function openExternalLink(link, options = {}) {
@@ -16955,7 +17845,8 @@
const { openInMiniApp = false } = options;
// Detect if we're on PC and trying to open a happ:// link
- const isPC = currentPlatform === 'pc' || (!['ios', 'android', 'tv'].includes(currentPlatform));
+ const platformKey = (detectedDevicePlatform || currentPlatform || '').toLowerCase();
+ const isPC = platformKey === 'pc' || (!['ios', 'android', 'tv'].includes(platformKey));
const isHappLink = link.startsWith('happ://');
if (isPC && isHappLink) {
@@ -17188,6 +18079,7 @@
const guideBtn = document.getElementById('openGuideBtn');
const connectLink = getConnectLink();
+ const anyConnectLink = hasAnyConnectLink();
const showConnectButton = hasActiveSubscription();
if (guideBtn) {
@@ -17199,7 +18091,7 @@
closeInstallationModal();
}
- updateInstructionConnectButtons(showConnectButton && Boolean(connectLink));
+ updateInstructionConnectButtons(showConnectButton && anyConnectLink);
const subscriptionUrl = getCurrentSubscriptionUrl();
if (copyBtn) {