@autobusal/common 1.26.0 → 1.27.0

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+
+## 1.27.0
+
+### Added
+
+- **`localeHref`** — the one URL a page has in a given language, once a brand
+  answers on more than one domain. A language either has a **domain of its
+  own** and lives at that domain's bare paths (`busmagus.ro/city/tirana`), or
+  it does not and keeps its `/{locale}/` prefix on the primary. Which of the
+  two is a property of the *language*, not of the page, so this is one
+  function every caller shares. The deliberate twin of obtapi's
+  `Libraries\Labels\LocaleUrl::href`. See `magus/MULTI_TLD_PLAN.md` item 4.
+
+  With no domain list — every brand today — it resolves to `origin + path`
+  and the prefix convention, exactly as before.
+
+### Changed
+
+- **`Meta`'s canonical is resolved through the domain that owns the page's
+  language**, not off `window.location.origin`. Three things follow that the
+  browser's own host cannot say: an **alias** (a `www.` host, a legacy domain
+  kept for old links) now canonicalises to the real site instead of declaring
+  itself the original; `/it/city/tirana` on the `.com` canonicalises to
+  `busmagus.it/city/tirana` once Italian has a domain, so the prefixed form
+  stops competing with the ccTLD that replaced it; and the canonical is built
+  by the same function as the hreflang set, so it is always one of its own
+  alternates — a canonical that is not is discarded by Google outright, and
+  nothing on the page would have shown it.
+
+- **`Meta`'s hreflang alternates point at domains** where a language has one
+  and keep their prefix where it does not. The set stays whole either way,
+  which is the part that matters: an hreflang cluster is treated as
+  reciprocal only when every member declares every other. `x-default`
+  follows the **primary's** language rather than the current origin's — a
+  `.ro` build announcing itself as x-default would offer Romanian to
+  everybody a search engine could not place.
+
+- **`ChangeLanguage` navigates across domains.** Choosing a language that has
+  its own domain leaves the site: another origin, its own bundle, its own
+  settings payload, so it cannot go through the router. The i18n change and
+  the stored preference are deliberately skipped on that path — they would
+  apply to the site being left, and storing the language you are walking away
+  from is how somebody returns to the `.com` later and finds it rendering
+  Italian at English URLs.
+
+## 1.26.1
+
+### Fixed
+
+- **`Table` drew an empty "Options" column when a table had only
+  top-of-table controls.** `create`, `search` and `extra` all live *above* the
+  table — `Actions/Get` already returns null for each — but `Header` and
+  `Rows` decided whether to draw the options column from `actions.length > 0`,
+  which counted them. A table using the component purely for sorting, search
+  and paging therefore got an "Options" heading with an empty cell under every
+  row.
+
+  Invisible on the admin screens, where every table has row actions anyway;
+  visible the moment the public bus-company directory used it. The row/top
+  split is one shared list now (`Table/rowActions.ts`) rather than a condition
+  repeated in three files that could drift.
+
 ## 1.26.0
 
 ### Added

package/ChangeLanguage/ChangeLanguage.tsx

@@ -3,7 +3,7 @@ import { TFunction, i18n } from 'i18next';
 import { useLocation, useNavigate } from 'react-router-dom';
 import { useOutside } from '@autobusal/hooks';
 import Flag from './Flag';
-import { withLocale } from '../Locale/locale';
+import { withLocale, localeHref } from '../Locale/locale';
 import { Container, Title, ContainerButtons, ButtonChange } from './styles';
 import { useGetSettings } from '@autobusal/providers/services';
 
@@ -55,6 +55,27 @@ const ChangeLanguage = ({ type, t, i18n, localised = false, onClose }: Props): J
    * language in place and stay put.
    */
   const onChange = (language: string): void => {
+    const tail = `${ location.search }${ location.hash }`;
+
+    // Edited: Ferjolt Ozuni - Date: 2026-08-06
+    // A language with a DOMAIN of its own lives on that domain, so choosing
+    // it leaves this site. That cannot go through the router - another
+    // origin, its own bundle, its own settings payload - so it is a real
+    // navigation, and the two state changes below are deliberately skipped:
+    // they would apply to the site being left rather than the one being
+    // opened, and storing the language we are walking away from is how
+    // somebody returns to the .com later and finds it rendering Italian at
+    // English URLs.
+    if (localised) {
+      const href = localeHref(location.pathname, language, fallback, available, data.domains ?? [], window.location.origin);
+
+      if (!href.startsWith(window.location.origin)) {
+        window.location.assign(`${ href }${ tail }`);
+
+        return;
+      }
+    }
+
     i18n.changeLanguage(language);
     localStorage.setItem('language', language);
 
@@ -62,7 +83,7 @@ const ChangeLanguage = ({ type, t, i18n, localised = false, onClose }: Props): J
       const to = withLocale(location.pathname, language, fallback, available);
 
       if (to !== location.pathname) {
-        navigate(`${ to }${ location.search }${ location.hash }`);
+        navigate(`${ to }${ tail }`);
       }
     }
 

package/Locale/locale.ts

@@ -58,6 +58,72 @@ export const withLocale = (pathname: string, locale: string, defaultLocale: stri
   return clean === '/' ? `/${ locale }` : `/${ locale }${ clean }`;
 };
 
+/**
+ * One origin a brand answers on, and the language it serves there.
+ *
+ * Ferjolt Ozuni - Date: 2026-08-06
+ * Mirrors obtapi's Settings\ViewController::domains(). `locale` may be null:
+ * an alias (a www. host, a legacy domain kept alive for old links) answers
+ * without claiming a language, so nothing points hreflang at it.
+ */
+export interface LocaleDomain {
+  domain: string
+  locale?: string | null
+  primary?: boolean
+}
+
+/**
+ * The ONE URL a page has in a given language.
+ *
+ * Ferjolt Ozuni - Date: 2026-08-06 - see magus/MULTI_TLD_PLAN.md item 4.
+ *
+ * A language reaches its own URL one of two ways, and which one is a
+ * property of the language rather than of the page:
+ *
+ *  - it has a DOMAIN of its own, and lives at that domain's bare paths -
+ *    busmagus.ro/city/tirana, not busmagus.com/ro/city/tirana;
+ *  - it does not, and lives under a /{locale}/ prefix on the primary.
+ *
+ * Both forms have to be derivable from anywhere, because the canonical, the
+ * hreflang set and the language switcher must agree to the character. They
+ * are the same claim about the same page said three times, and a canonical
+ * that is not itself in its own hreflang set is discarded outright.
+ *
+ * `fallbackOrigin` is what to call "here" when the brand has no domain list
+ * at all - an older API, or a payload that has not arrived. It resolves to
+ * the previous single-origin behaviour exactly, which is why this is safe to
+ * put on every page before any brand has a second domain.
+ */
+export const localeHref = (
+  pathname: string,
+  locale: string,
+  defaultLocale: string,
+  available: string[],
+  domains: LocaleDomain[],
+  fallbackOrigin: string
+): string => {
+  const { path } = splitLocale(pathname, available);
+
+  const clean = path === '' ? '/' : path;
+
+  const owner = domains.find(item => item.locale === locale);
+
+  if (owner) {
+    return owner.domain + clean;
+  }
+
+  const primary = domains.find(item => item.primary);
+
+  // Which language is unprefixed on the primary - NOT `defaultLocale`, which
+  // on a ccTLD is that ccTLD's own language (obtapi answers the per-origin
+  // question there). Reading it from the primary row is what stops the .ro
+  // build announcing English as busmagus.com/en/... when English is the
+  // thing that lives at busmagus.com/... itself.
+  const unprefixed = primary?.locale ?? defaultLocale;
+
+  return (primary?.domain ?? fallbackOrigin) + withLocale(clean, locale, unprefixed, available);
+};
+
 /**
  * Which language a URL is asking for, falling back to the stored preference
  * and then the brand default.

package/Meta.tsx

@@ -1,6 +1,6 @@
 import { useEffect } from 'react';
 import { useLocation } from 'react-router-dom';
-import { splitLocale, withLocale } from './Locale/locale';
+import { splitLocale, localeHref } from './Locale/locale';
 import { pageview } from '@autobusal/providers/Setup/analytics';
 import { useGetSettings } from '@autobusal/providers/services';
 
@@ -155,10 +155,45 @@ const normalisePath = (pathname: string): string => (
   pathname.length > 1 && pathname.endsWith('/') ? pathname.replace(/\/+$/, '') : pathname
 );
 
+/**
+ * Edited: Ferjolt Ozuni - Date: 2026-08-06
+ * Resolved through the domain that OWNS this page's language rather than off
+ * whichever host the visitor happens to be on - see localeHref and
+ * magus/MULTI_TLD_PLAN.md item 4.
+ *
+ * Three things fall out of that which `window.location.origin` cannot say:
+ *
+ *  - an ALIAS (a www. host, a legacy domain kept alive for old links) now
+ *    canonicalises to the real site instead of declaring itself the
+ *    original, which is the whole job of a canonical and the one case where
+ *    taking it from the browser is actively wrong;
+ *  - /it/city/tirana served from the .com canonicalises to
+ *    busmagus.it/city/tirana once Italian has a domain, so the prefixed form
+ *    stops competing with the ccTLD that replaced it;
+ *  - the canonical is built by the same function as the hreflang set, so it
+ *    is always one of its own alternates. A canonical that is not is
+ *    discarded by Google outright, and nothing on the page would show it.
+ *
+ * With no domain list this is `origin + path`, exactly as before.
+ */
 const useCanonicalUrl = (explicit?: string): string => {
   const location = useLocation();
 
-  return explicit ?? `${ window.location.origin }${ normalisePath(location.pathname) }`;
+  const { data } = useGetSettings();
+
+  if (explicit) {
+    return explicit;
+  }
+
+  const available = data?.preferences?.languages?.available ?? [];
+
+  const fallback = data?.preferences?.languages?.default ?? 'en';
+
+  const path = normalisePath(location.pathname);
+
+  const { locale } = splitLocale(path, available);
+
+  return localeHref(path, locale ?? fallback, fallback, available, data?.domains ?? [], window.location.origin);
 };
 
 // A single-page app never reloads, so GTM's page-load trigger fires exactly
@@ -207,6 +242,19 @@ const usePageviewTracking = (path: string, title: string): void => {
  * Suppressed for noindex pages: they have nothing to offer alternates for,
  * and telling a crawler about language variants of a page it has just been
  * asked not to index is noise at best.
+ *
+ * Edited: Ferjolt Ozuni - Date: 2026-08-06
+ * Each language now resolves to the DOMAIN that owns it where it has one,
+ * and keeps its /{locale}/ prefix on the primary where it does not - see
+ * localeHref. The set stays whole either way, which is the part that
+ * matters: Google treats an hreflang cluster as reciprocal only when every
+ * member declares every other, so a page cannot list "the domains" and leave
+ * out the languages that have none.
+ *
+ * x-default follows the PRIMARY's own language rather than this origin's.
+ * The .com is the answer when there is no signal about the visitor; a .ro
+ * build announcing itself as x-default would be offering Romanian to
+ * everyone the search engine could not place.
  */
 const useAlternates = (noIndex: boolean, explicitUrl?: string): { locale: string, href: string }[] => {
   const location = useLocation();
@@ -226,13 +274,20 @@ const useAlternates = (noIndex: boolean, explicitUrl?: string): { locale: string
 
   const origin = window.location.origin;
 
+  const domains = data?.domains ?? [];
+
   const { path } = splitLocale(normalisePath(location.pathname), available);
 
+  // The primary's own language, so x-default lands on the .com. Falls back
+  // to this origin's default when there is no domain list at all, which is
+  // the single-domain case and exactly the previous behaviour.
+  const neutral = domains.find(item => item.primary)?.locale ?? fallback;
+
   return [
-    { locale: 'x-default', href: `${ origin }${ withLocale(path, fallback, fallback, available) }` },
+    { locale: 'x-default', href: localeHref(path, neutral, fallback, available, domains, origin) },
     ...available.map(locale => ({
       locale,
-      href: `${ origin }${ withLocale(path, locale, fallback, available) }`
+      href: localeHref(path, locale, fallback, available, domains, origin)
     }))
   ];
 };

package/Table/Header/Header.tsx

@@ -1,6 +1,7 @@
 import { TFunction } from 'i18next';
 import Sort from './Sort';
 import { getUrl } from '../browseUrl';
+import { rowActions } from '../rowActions';
 import { Container, Td, Column, Text } from './styles';
 import { ColumnData, SortingData } from '../types';
 
@@ -31,7 +32,7 @@ const Header = ({ url, data, sorting, t, actions }: Props): JSX.Element => {
       <tr>
         { columns }
 
-        { (actions !== undefined && actions.length > 0) && (
+        { rowActions(actions).length > 0 && (
           <Td $width={ 10 }>
             <Column>
               <Text>{ t('table.options', { ns: 'common' }) }</Text>

package/Table/Rows/Rows.tsx

@@ -3,6 +3,7 @@ import { NavigateFunction } from 'react-router-dom';
 import Loading from './Loading';
 import NotFound from './NotFound';
 import Actions from '../Actions/Actions';
+import { rowActions } from '../rowActions';
 import { Tbody, Tr } from './styles';
 
 interface Props {
@@ -39,7 +40,7 @@ const Rows = ({ url, urlWith, data, loading, fetching, colLength, t, actions, ha
     <Tr key={ index } $viewable={ isViewable } onClick={ () => onClick(item.props.id) }>
       { item }
 
-      { (actions !== undefined && actions.length > 0) && (
+      { rowActions(actions).length > 0 && (
         <Actions
           id={ item.props.id }
           url={ url }

package/Table/rowActions.ts

@@ -0,0 +1,22 @@
+/**
+ * Which of a table's actions belong to a ROW rather than to the top of the
+ * table.
+ *
+ * Ferjolt Ozuni - Date: 2026-08-06
+ *
+ * `create`, `search` and `extra` are all controls that live ABOVE the table -
+ * Top renders them and Actions/Get already returns null for each. But Header
+ * and Rows both decided whether to draw the options column from
+ * `actions.length > 0`, counting those three, so a table with only
+ * top-of-table controls got an "Options" heading with an empty cell under
+ * every row. Harmless on the admin screens, where every table has row actions
+ * anyway - visible the moment a PUBLIC page used the component for its
+ * sorting and paging alone.
+ *
+ * One list, shared by the three places that need it, so it cannot drift.
+ */
+export const TOP_ACTIONS = ['create', 'search', 'extra'];
+
+export const rowActions = (actions?: string[]): string[] => (
+  (actions ?? []).filter(action => !TOP_ACTIONS.includes(action))
+);

package/index.ts

@@ -36,7 +36,7 @@ import LocaleGate from './Locale/LocaleGate';
 import SeoOverride from './SeoOverride/SeoOverride';
 import HandoffBanner from './HandoffBanner/HandoffBanner';
 import localiseRoutes from './Locale/routes';
-import { splitLocale, withLocale, localeFromPath } from './Locale/locale';
+import { splitLocale, withLocale, localeFromPath, localeHref } from './Locale/locale';
 import RouteItem from './RouteItem/RouteItem';
 import Row from './Table/Row';
 import Table from './Table/Table';
@@ -91,10 +91,13 @@ export {
   splitLocale,
   withLocale,
   localeFromPath,
+  localeHref,
   RouteItem,
   Row,
   Table,
   UnderConstruction,
   useUnderConstruction,
   Viewer
-};
+};
+
+export type { LocaleDomain } from './Locale/locale';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobusal/common",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "author": "Ferjolt Ozuni",
   "type": "module",
   "main": "index.ts"