@salesforcedevs/dx-components 1.40.0-alpha → 1.40.0-banner-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforcedevs/dx-components",
-  "version": "1.40.0-alpha",
+  "version": "1.40.0-banner-alpha",
   "description": "DX Lightning web components",
   "license": "MIT",
   "engines": {

package/src/modules/dxUtils/topicVersion/topicVersion.ts

@@ -378,31 +378,88 @@ export function getVersionPickerOptions(
     }));
 }
 
-export function resolveSelectedVersion(
+/**
+ * Version whose page (or a descendant of it) is the current URL.
+ * Ignores the session-stored picker selection, which can remember an older
+ * version while the reader is still on the latest page.
+ */
+export function versionForCurrentPage(
     node: VersionedNode | undefined
 ): TopicVersionOption | undefined {
     const versions = node?.versions;
-    if (!node || !versions?.length) {
+    if (!node || !versions?.length || !isBrowser()) {
         return undefined;
     }
 
-    const fromOwnUrl = versions.find((version) =>
-        hrefMatchesCurrentPage(version.link?.href)
+    const hrefs = collectSubtreeCanonicalHrefs(node);
+    const matches = (version: TopicVersionOption) =>
+        hrefMatchesCurrentPage(version.link?.href) ||
+        hrefs.some((href) => hrefMatchesVersion(href, version, versions));
+
+    // Older versions first so a rewritten child URL is not mistaken for latest.
+    const older = versions.find(
+        (version) => version.id !== versions[0].id && matches(version)
     );
-    if (fromOwnUrl) {
-        return fromOwnUrl;
+    if (older) {
+        return older;
     }
 
-    const descendantHrefs = collectSubtreeCanonicalHrefs(node, false);
-    const fromDescendant = versions.find(
-        (version) =>
-            version.id !== versions[0].id &&
-            descendantHrefs.some((href) =>
-                hrefMatchesVersion(href, version, versions)
-            )
-    );
-    if (fromDescendant) {
-        return fromDescendant;
+    return matches(versions[0]) ? versions[0] : undefined;
+}
+
+/**
+ * Deepest versioned topic that contains the current page, with the version
+ * the URL selects. Nested versioned topics own their pages.
+ */
+export function findTopicVersionForCurrentPage(
+    nodes: VersionedNode[] | undefined | null
+): { node: VersionedNode; version: TopicVersionOption } | undefined {
+    let match: { node: VersionedNode; version: TopicVersionOption } | undefined;
+    const walk = (list?: VersionedNode[] | null) => {
+        for (const node of list || []) {
+            const version = versionForCurrentPage(node);
+            if (version) {
+                match = { node, version };
+            }
+            walk(node.children);
+        }
+    };
+    walk(nodes);
+    return match;
+}
+
+/**
+ * Current page rewritten onto the latest topic version. Falls back to the
+ * latest switching URL when the path delta cannot be applied.
+ */
+export function latestHrefForCurrentPage(
+    versions: TopicVersionOption[] | undefined
+): string | undefined {
+    const latest = versions?.[0];
+    if (!latest) {
+        return undefined;
+    }
+    if (!isBrowser()) {
+        return latest.link?.href;
+    }
+
+    const canonical = toCanonicalHref(window.location.pathname, versions);
+    return applyVersionToHref(canonical, latest, versions) || latest.link?.href;
+}
+
+export function resolveSelectedVersion(
+    node: VersionedNode | undefined
+): TopicVersionOption | undefined {
+    const versions = node?.versions;
+    if (!node || !versions?.length) {
+        return undefined;
+    }
+
+    // The open page wins, including a canonical child opened from "View Latest".
+    // Session is only for a picker whose topic is not the current page.
+    const fromUrl = versionForCurrentPage(node);
+    if (fromUrl) {
+        return fromUrl;
     }
 
     const storedId = readTopicVersionSelections()[getTopicVersionKey(node)];