@antora/content-classifier 3.1.11 → 3.1.12

package/lib/classify-content.js

@@ -10,66 +10,50 @@ const summarizeFileLocation = require('./util/summarize-file-location')
  *
  * @memberof content-classifier
  *
- * @param {Object} playbook - The configuration object for Antora. See ContentCatalog constructor for relevant keys.
+ * @param {Object} playbook - The configuration object for Antora.
  * @param {Object} playbook.site - Site-related configuration data.
  * @param {String} playbook.site.startPage - The start page for the site; redirects from base URL.
+ * @param {Object} playbook.urls - URL settings for the site.
+ * @param {String} playbook.urls.htmlExtensionStyle - The style to use when computing page URLs.
  * @param {Object} aggregate - The raw aggregate of virtual file objects to be classified.
  * @param {Object} [siteAsciiDocConfig={}] - Site-wide AsciiDoc processor configuration options.
- * @param {Function} [onComponentsRegistered] - A function (optionally async) to invoke after components are
- *  registered. Must return an instance of ContentCatalog. If async, this function will also return a Promise.
- *
- * @returns {ContentCatalog} A structured catalog of content components, versions, and virtual content files.
+ * @returns {ContentCatalog} A structured catalog of content components and virtual content files.
  */
-function classifyContent (playbook, aggregate, siteAsciiDocConfig = {}, onComponentsRegistered = undefined) {
-  const siteStartPage = playbook.site.startPage
-  let contentCatalog = registerComponentVersions(new ContentCatalog(playbook), aggregate, siteAsciiDocConfig)
-  return typeof onComponentsRegistered === 'function' &&
-    (contentCatalog = onComponentsRegistered(contentCatalog)) instanceof Promise
-    ? contentCatalog.then((contentCatalogValue) => addFilesAndRegisterStartPages(contentCatalogValue, siteStartPage))
-    : addFilesAndRegisterStartPages(contentCatalog, siteStartPage)
-}
-
-function registerComponentVersions (contentCatalog, aggregate, siteAsciiDocConfig) {
-  for (const componentVersionBucket of aggregate) {
-    // advance files, nav, and startPage to component version to be used in later phase
-    const { name, version, files, nav, startPage, ...data } = Object.assign(componentVersionBucket, {
-      asciidoc: resolveAsciiDocConfig(siteAsciiDocConfig, componentVersionBucket),
-    })
-    Object.assign(contentCatalog.registerComponentVersion(name, version, data), { files, nav, startPage })
-  }
-  return contentCatalog
-}
-
-function addFilesAndRegisterStartPages (contentCatalog, siteStartPage) {
-  for (const { versions: componentVersions } of contentCatalog.getComponents()) {
-    for (const componentVersion of componentVersions) {
-      const { name: component, version, files = [], nav, startPage } = componentVersion
+function classifyContent (playbook, aggregate, siteAsciiDocConfig = {}) {
+  const contentCatalog = new ContentCatalog(playbook)
+  aggregate
+    .reduce((accum, componentVersionData) => {
+      // drop files since they aren't needed to register component version
+      // drop startPage to defer registration of start page
+      const { name, version, files, startPage, ...descriptor } = Object.assign({}, componentVersionData, {
+        asciidoc: resolveAsciiDocConfig(siteAsciiDocConfig, componentVersionData),
+      })
+      return new Map(accum).set(
+        contentCatalog.registerComponentVersion(name, version, descriptor),
+        componentVersionData
+      )
+    }, new Map())
+    .forEach((componentVersionData, componentVersion) => {
+      const { name, version } = componentVersion
+      const { files, nav, startPage } = componentVersionData
       const navResolved = nav && (nav.resolved = new Set())
-      for (let file, i = 0, len = files.length; i < len; i++) {
-        allocateSrc((file = files[i]), component, version, nav) && contentCatalog.addFile(file, componentVersion)
-        files[i] = undefined // free memory
-      }
+      componentVersionData.files = undefined // clean up memory
+      files.forEach((file) => allocateSrc(file, name, version, nav) && contentCatalog.addFile(file))
       if (navResolved && nav.length > navResolved.size && new Set(nav).size > navResolved.size) {
         const loc = summarizeFileLocation({ path: 'antora.yml', src: { origin: nav.origin } })
         for (const filepath of nav) {
           if (navResolved.has(filepath)) continue
-          logger.warn('Could not resolve nav entry for %s@%s defined in %s: %s', version, component, loc, filepath)
+          logger.warn('Could not resolve nav entry for %s@%s defined in %s: %s', version, name, loc, filepath)
         }
       }
-      contentCatalog.registerComponentVersionStartPage(component, componentVersion, startPage)
-    }
-  }
-  contentCatalog.registerSiteStartPage(siteStartPage)
+      contentCatalog.registerComponentVersionStartPage(name, componentVersion, startPage)
+    })
+  contentCatalog.registerSiteStartPage(playbook.site.startPage)
   return contentCatalog
 }
 
 function allocateSrc (file, component, version, nav) {
-  const { extname, family } = file.src
-  if (family && family !== 'nav') {
-    Object.assign(file.src, { component, version })
-    file.src.moduleRootPath ??= calculateRootPath(file.src.relative.split('/').length)
-    return true
-  }
+  const extname = file.src.extname
   const filepath = file.path
   const pathSegments = filepath.split('/')
   let navInfo
@@ -156,19 +140,13 @@ function getNavInfo (filepath, nav) {
   if (~index) return nav.resolved.add(filepath) && { index }
 }
 
-function resolveAsciiDocConfig (siteAsciiDocConfig, { name, version, asciidoc, origins = [] }) {
+function resolveAsciiDocConfig (siteAsciiDocConfig, { asciidoc, origins = [] }) {
   const scopedAttributes = asciidoc?.attributes
   if (scopedAttributes) {
-    const initial = Object.assign({}, siteAsciiDocConfig.attributes)
-    initial['antora-component-name'] = name
-    initial['antora-component-version'] = version
+    const initial = siteAsciiDocConfig.attributes
     const mdc = { file: { path: 'antora.yml', origin: origins[origins.length - 1] } }
     const attributes = collateAsciiDocAttributes(scopedAttributes, { initial, mdc, merge: true })
-    if (attributes !== initial) {
-      delete attributes['antora-component-name']
-      delete attributes['antora-component-version']
-      return Object.assign({}, siteAsciiDocConfig, { attributes })
-    }
+    if (attributes !== initial) siteAsciiDocConfig = Object.assign({}, siteAsciiDocConfig, { attributes })
   }
   return siteAsciiDocConfig
 }

package/lib/content-catalog.js

@@ -5,12 +5,13 @@ const invariably = { void: () => undefined }
 const logger = require('./logger')
 const { lookup: resolveMimeType } = require('./mime-types-with-asciidoc')
 const parseResourceId = require('./util/parse-resource-id')
-const { posix: path } = require('node:path')
+const { posix: path } = require('path')
 const resolveResource = require('./util/resolve-resource')
 const summarizeFileLocation = require('./util/summarize-file-location')
 const versionCompare = require('./util/version-compare-desc')
 
 const { ROOT_INDEX_ALIAS_ID, ROOT_INDEX_PAGE_ID } = require('./constants')
+const SPACE_RX = / /g
 const LOG_WRAP = '\n    '
 
 const $components = Symbol('components')
@@ -23,17 +24,17 @@ class ContentCatalog {
     const urls = playbook.urls || {}
     this.htmlUrlExtensionStyle = urls.htmlExtensionStyle || 'default'
     this.urlRedirectFacility = urls.redirectFacility || 'static'
-    this.latestVersionSegment = urls.latestVersionSegment
-    this.latestPrereleaseVersionSegment = urls.latestPrereleaseVersionSegment
-    if (this.latestVersionSegment == null && this.latestPrereleaseVersionSegment == null) {
-      this.latestVersionSegmentStrategy = undefined
+    this.latestVersionUrlSegment = urls.latestVersionSegment
+    this.latestPrereleaseVersionUrlSegment = urls.latestPrereleaseVersionSegment
+    if (this.latestVersionUrlSegment == null && this.latestPrereleaseVersionUrlSegment == null) {
+      this.latestVersionUrlSegmentStrategy = undefined
     } else {
-      this.latestVersionSegmentStrategy = urls.latestVersionSegmentStrategy || 'replace'
-      if (this.latestVersionSegmentStrategy === 'redirect:from') {
-        if (!this.latestVersionSegment) this.latestVersionSegment = undefined
-        if (!this.latestPrereleaseVersionSegment) {
-          this.latestPrereleaseVersionSegment = undefined
-          if (!this.latestVersionSegment) this.latestVersionSegmentStrategy = undefined
+      this.latestVersionUrlSegmentStrategy = urls.latestVersionSegmentStrategy || 'replace'
+      if (this.latestVersionUrlSegmentStrategy === 'redirect:from') {
+        if (!this.latestVersionUrlSegment) this.latestVersionUrlSegment = undefined
+        if (!this.latestPrereleaseVersionUrlSegment) {
+          this.latestPrereleaseVersionUrlSegment = undefined
+          if (!this.latestVersionUrlSegment) this.latestVersionUrlSegmentStrategy = undefined
         }
       }
     }
@@ -42,8 +43,6 @@ class ContentCatalog {
   /**
    * Registers a new component version with the content catalog. Also registers the component if it does not yet exist.
    *
-   * Must be followed by a call to registerComponentVersionStartPage to finalize object.
-   *
    * @param {String} name - The name of the component to which this component version belongs.
    * @param {String} version - The version of the component to register.
    * @param {Object} [descriptor={}] - The configuration data for the component version.
@@ -60,9 +59,8 @@ class ContentCatalog {
    * @returns {Object} The constructed component version object.
    */
   registerComponentVersion (name, version, descriptor = {}) {
-    const { asciidoc, displayVersion, prerelease, startPage: startPageSpec, title, versionSegment } = descriptor
+    const { asciidoc, displayVersion, prerelease, startPage: startPageSpec, title } = descriptor
     const componentVersion = { displayVersion: displayVersion || version || 'default', title: title || name, version }
-    if (versionSegment != null) componentVersion.versionSegment = versionSegment
     Object.defineProperty(componentVersion, 'name', { value: name, enumerable: true })
     if (prerelease) {
       componentVersion.prerelease = prerelease
@@ -131,15 +129,14 @@ class ContentCatalog {
       )
     }
     if (startPageSpec) {
-      // @deprecated use separate call to register start page for component version
       this.registerComponentVersionStartPage(name, componentVersion, startPageSpec === true ? undefined : startPageSpec)
     }
     return componentVersion
   }
 
-  addFile (file, componentVersion) {
+  addFile (file) {
     const src = file.src
-    let { component, version, family } = src
+    let family = src.family
     let filesForFamily = this[$files].get(family)
     if (!filesForFamily) this[$files].set(family, (filesForFamily = new Map()))
     const key = generateKey(src)
@@ -151,30 +148,30 @@ class ContentCatalog {
         .map((it, idx) => `${idx + 1}: ${summarizeFileLocation(it)}`)
         .join(LOG_WRAP)
       if (family === 'nav') {
-        throw new Error(`Duplicate nav file: ${file.path} in ${version}@${component}${LOG_WRAP}${details}`)
+        throw new Error(`Duplicate nav in ${src.version}@${src.component}: ${file.path}${LOG_WRAP}${details}`)
       }
       throw new Error(`Duplicate ${family}: ${generateResourceSpec(src)}${LOG_WRAP}${details}`)
     }
-    // NOTE: assume that if the file is not a vinyl object, the src likely needs to be prepared
+    // NOTE: if the path property is not set, assume the src likely needs to be prepared
+    // another option is to assume that if the file is not a vinyl object, the src likely needs to be prepared
     // a vinyl object is one indication the file was created and prepared by the content aggregator
-    // an alternate approach would be to call prepareSrc if the path property is not set
+    //if (!src.path) prepareSrc(src)
+    //if (!File.isVinyl(file)) file = new File(file)
     if (!File.isVinyl(file)) {
       prepareSrc(src)
       file = new File(file)
     }
     if (family === 'alias') {
+      src.mediaType = 'text/asciidoc'
       file.mediaType = 'text/html'
       // NOTE: an alias masquerades as the target file
       family = file.rel.src.family
-      // NOTE: short circuit in case of splat alias (alias -> alias)
-      if (family === 'alias' && file.pub?.splat) return filesForFamily.set(key, file) && file
-      src.mediaType = 'text/asciidoc'
-    } else if (!(file.mediaType = src.mediaType) && !('mediaType' in src)) {
       // QUESTION: should we preserve the mediaType property on file if already defined?
+    } else if (!(file.mediaType = src.mediaType) && !('mediaType' in src)) {
       file.mediaType = src.mediaType = resolveMimeType(src.extname) || (family === 'page' ? 'text/asciidoc' : undefined)
     }
     let publishable
-    let activeVersionSegment
+    let versionSegment
     if (file.out) {
       publishable = true
     } else if ('out' in file) {
@@ -184,24 +181,15 @@ class ContentCatalog {
       ('/' + src.relative).indexOf('/_') < 0
     ) {
       publishable = true
-      if (componentVersion == null) componentVersion = this.getComponentVersion(component, version) || { version }
-      activeVersionSegment =
-        'activeVersionSegment' in componentVersion
-          ? componentVersion.activeVersionSegment
-          : computeVersionSegment.call(this, componentVersion)
-      file.out = computeOut(src, family, activeVersionSegment, this.htmlUrlExtensionStyle)
+      versionSegment = computeVersionSegment.call(this, src.component, src.version)
+      file.out = computeOut(src, family, versionSegment, this.htmlUrlExtensionStyle)
     }
     if (!file.pub && (publishable || family === 'nav')) {
-      if (activeVersionSegment == null) {
-        if (componentVersion == null) componentVersion = this.getComponentVersion(component, version) || { version }
-        activeVersionSegment =
-          'activeVersionSegment' in componentVersion
-            ? componentVersion.activeVersionSegment
-            : computeVersionSegment.call(this, componentVersion)
-      }
-      file.pub = computePub(src, file.out, family, activeVersionSegment, this.htmlUrlExtensionStyle)
+      if (versionSegment == null) versionSegment = computeVersionSegment.call(this, src.component, src.version)
+      file.pub = computePub(src, file.out, family, versionSegment, this.htmlUrlExtensionStyle)
     }
-    return filesForFamily.set(key, file) && file
+    filesForFamily.set(key, file)
+    return file
   }
 
   removeFile (file) {
@@ -278,48 +266,38 @@ class ContentCatalog {
 
   // TODO add `follow` argument to control whether alias is followed
   getSiteStartPage () {
-    let file
-    if ((file = this.getById(ROOT_INDEX_PAGE_ID))) return file
-    if ((file = this.getById(ROOT_INDEX_ALIAS_ID))) return file.rel
-    const rootComponent = this.getComponent('ROOT')
-    if (!rootComponent) return
-    const version = rootComponent.versions.find(({ activeVersionSegment }) => activeVersionSegment === '')?.version
-    if (!version) return
-    if ((file = this.getById(Object.assign({}, ROOT_INDEX_PAGE_ID, { version })))) return file
-    if ((file = this.getById(Object.assign({}, ROOT_INDEX_ALIAS_ID, { version })))) return file.rel
+    return this.getById(ROOT_INDEX_PAGE_ID) || this.getById(ROOT_INDEX_ALIAS_ID)?.rel
   }
 
   registerComponentVersionStartPage (name, componentVersion, startPageSpec = undefined) {
-    const component = name
     let version = componentVersion.version
     if (version == null) {
       // QUESTION: should we warn or throw error if component version cannot be found?
-      if (!(componentVersion = this.getComponentVersion(component, componentVersion))) return
+      if (!(componentVersion = this.getComponentVersion(name, componentVersion))) return
       version = componentVersion.version
     }
-    const activeVersionSegment = computeVersionSegment.call(this, componentVersion)
     let startPage
     let startPageSrc
-    const indexPageId = Object.assign({}, ROOT_INDEX_PAGE_ID, { component, version })
+    const indexPageId = Object.assign({}, ROOT_INDEX_PAGE_ID, { component: name, version })
     if (startPageSpec) {
       if (
         (startPage = this.resolvePage(startPageSpec, indexPageId)) &&
-        (startPageSrc = startPage.src).component === component &&
+        (startPageSrc = startPage.src).component === name &&
         startPageSrc.version === version
       ) {
         if (!this.getById(indexPageId)) {
-          const indexAliasId = Object.assign({}, ROOT_INDEX_ALIAS_ID, { component, version })
+          const indexAliasId = Object.assign({}, ROOT_INDEX_ALIAS_ID, { component: name, version })
           const indexAlias = this.getById(indexAliasId)
           indexAlias
             ? indexAlias.synthetic && Object.assign(indexAlias, { rel: startPage })
-            : this.addFile({ src: indexAliasId, rel: startPage, synthetic: true }, componentVersion)
+            : this.addFile({ src: indexAliasId, rel: startPage, synthetic: true })
         }
       } else {
         // TODO pass componentVersion as logObject
         logger.warn(
           'Start page specified for %s@%s %s: %s',
           version,
-          component,
+          name,
           startPage === false ? 'has invalid syntax' : 'not found',
           startPageSpec
         )
@@ -330,34 +308,25 @@ class ContentCatalog {
     }
     if (startPage) {
       componentVersion.url = startPage.pub.url
-    } else if (!componentVersion.url) {
+    } else {
       // QUESTION: should we warn if the default start page cannot be found?
+      const versionSegment = computeVersionSegment.call(this, name, version)
       componentVersion.url = computePub(
         (startPageSrc = prepareSrc(Object.assign({}, indexPageId, { family: 'page' }))),
-        computeOut(startPageSrc, startPageSrc.family, activeVersionSegment, this.htmlUrlExtensionStyle),
+        computeOut(startPageSrc, startPageSrc.family, versionSegment, this.htmlUrlExtensionStyle),
         startPageSrc.family,
-        activeVersionSegment,
+        versionSegment,
         this.htmlUrlExtensionStyle
       ).url
     }
-    Object.defineProperties(componentVersion, {
-      activeVersionSegment:
-        activeVersionSegment === version
-          ? { configurable: true, enumerable: false, get: getVersion }
-          : { configurable: true, enumerable: false, value: activeVersionSegment },
-      files: {
-        configurable: true,
-        enumerable: false,
-        get: getComponentVersionFiles.bind(this, { component, version }),
-      },
-      startPage: {
-        configurable: true,
-        enumerable: false,
-        get: getComponentVersionStartPage.bind(this, { component, version }),
-      },
-    })
-    addSymbolicVersionAlias.call(this, componentVersion)
-    return startPage
+
+    const symbolicVersionAlias = createSymbolicVersionAlias(
+      name,
+      version,
+      computeVersionSegment.call(this, name, version, 'alias'),
+      this.latestVersionUrlSegmentStrategy
+    )
+    if (symbolicVersionAlias) this.addFile(symbolicVersionAlias)
   }
 
   registerSiteStartPage (startPageSpec) {
@@ -365,9 +334,9 @@ class ContentCatalog {
     const rel = this.resolvePage(startPageSpec)
     if (rel) {
       if (this.getById(ROOT_INDEX_PAGE_ID)) return
-      if (rel.pub.url === (this.htmlUrlExtensionStyle === 'default' ? '/index.html' : '/')) return
       const rootIndexAlias = this.getById(ROOT_INDEX_ALIAS_ID)
       if (rootIndexAlias) return rootIndexAlias.synthetic ? Object.assign(rootIndexAlias, { rel }) : undefined
+      if (rel.pub.url === (this.htmlUrlExtensionStyle === 'default' ? '/index.html' : '/')) return
       const src = Object.assign({}, ROOT_INDEX_ALIAS_ID)
       return this.addFile({ src, rel, synthetic: true }, { version: src.version })
     }
@@ -388,14 +357,9 @@ class ContentCatalog {
     // QUESTION should we throw an error if alias is invalid?
     if (!src || (inferredSpec && src.relative === '.adoc')) return
     const component = this.getComponent(src.component)
-    let componentVersion
     if (component) {
       // NOTE version is not set when alias specifies a component, but not a version
-      if (src.version == null) {
-        src.version = (componentVersion = component.latest).version
-      } else {
-        componentVersion = this.getComponentVersion(component, src.version)
-      }
+      if (src.version == null) src.version = component.latest.version
       const existingPage = this.getById(src)
       if (existingPage) {
         throw new Error(
@@ -420,34 +384,12 @@ class ContentCatalog {
       )
     }
     // NOTE the redirect producer will populate contents when the redirect facility is 'static'
-    const alias = this.addFile({ src, rel: target }, componentVersion)
+    const alias = this.addFile({ src, rel: target })
     // NOTE record the first alias this target claims as the preferred one
     if (!target.rel) target.rel = alias
     return alias
   }
 
-  /**
-   * Adds a splat (directory) alias from the specified version segment in one component to the specified
-   * version segment in the same or different component.
-   *
-   * @returns {File} The virtual file that represents the splat alias.
-   */
-  addSplatAlias (from, to) {
-    if (!from.versionSegment) throw new Error('cannot map splat alias from empty version segment')
-    const family = 'alias'
-    const baseSrc = { module: 'ROOT', family, relative: '', basename: '', stem: '', extname: '' }
-    const basePub = { splat: true }
-    const { component: fromComponent = to.component, versionSegment: fromVersionSegment } = from
-    const fromSrc = Object.assign({ component: fromComponent, version: fromVersionSegment }, baseSrc)
-    const fromPub = Object.assign(computePub(fromSrc, computeOut(fromSrc, family, fromVersionSegment), family), basePub)
-    const { component: toComponent, version: toVersion } = to
-    const toVersionSegment =
-      to.versionSegment ?? this.getComponentVersion(toComponent, toVersion)?.activeVersionSegment ?? toVersion
-    const toSrc = Object.assign({ component: toComponent, version: toVersion ?? toVersionSegment }, baseSrc)
-    const toPub = Object.assign(computePub(toSrc, computeOut(toSrc, family, toVersionSegment), family), basePub)
-    return this.addFile({ pub: fromPub, src: fromSrc, rel: { pub: toPub, src: toSrc } })
-  }
-
   /**
    * Attempts to resolve a page reference within the given context to a page in the catalog.
    *
@@ -532,28 +474,32 @@ function generateResourceSpec ({ component, version, module: module_, family, re
 
 function prepareSrc (src) {
   let { basename, extname, stem } = src
+  let update
   if (basename == null) {
-    basename = src.basename = path.basename(src.relative)
+    update = true
+    basename = path.basename(src.relative)
   }
   if (stem == null) {
+    update = true
     if (extname == null) {
       if (~(extname = basename.lastIndexOf('.'))) {
-        src.stem = basename.substr(0, extname)
-        src.extname = basename.substr(extname)
+        stem = basename.substr(0, extname)
+        extname = basename.substr(extname)
       } else {
-        src.stem = basename
-        src.extname = ''
+        stem = basename
+        extname = ''
       }
     } else {
-      src.stem = basename.substr(0, basename.length - extname.length)
+      stem = basename.substr(0, basename.length - extname.length)
     }
   } else if (extname == null) {
-    src.extname = basename.substr(stem.length)
+    update = true
+    extname = basename.substr(stem.length)
   }
-  return src
+  return update ? Object.assign(src, { basename, extname, stem }) : src
 }
 
-function computeOut (src, family, versionSegment, htmlUrlExtensionStyle) {
+function computeOut (src, family, version, htmlUrlExtensionStyle) {
   let { component, module: module_, basename, extname, relative, stem } = src
   if (component === 'ROOT') component = ''
   if (module_ === 'ROOT') module_ = ''
@@ -573,7 +519,7 @@ function computeOut (src, family, versionSegment, htmlUrlExtensionStyle) {
     familyPathSegment = '_attachments'
   }
 
-  const modulePath = path.join(component, versionSegment, module_)
+  const modulePath = path.join(component, version, module_)
   const dirname = path.join(modulePath, familyPathSegment, path.dirname(relative), indexifyPathSegment)
   const path_ = path.join(dirname, basename)
   const moduleRootPath = path.relative(dirname, modulePath) || '.'
@@ -582,13 +528,13 @@ function computeOut (src, family, versionSegment, htmlUrlExtensionStyle) {
   return { dirname, basename, path: path_, moduleRootPath, rootPath }
 }
 
-function computePub (src, out, family, versionSegment, htmlUrlExtensionStyle) {
+function computePub (src, out, family, version, htmlUrlExtensionStyle) {
   const pub = {}
   let url
   if (family === 'nav') {
     const component = src.component || 'ROOT'
     const urlSegments = component === 'ROOT' ? [] : [component]
-    if (versionSegment) urlSegments.push(versionSegment)
+    if (version) urlSegments.push(version)
     const module_ = src.module || 'ROOT'
     if (module_ !== 'ROOT') urlSegments.push(module_)
     if (urlSegments.length) urlSegments.push('')
@@ -607,61 +553,71 @@ function computePub (src, out, family, versionSegment, htmlUrlExtensionStyle) {
       urlSegments[lastUrlSegmentIdx] = ''
     }
     url = '/' + urlSegments.join('/')
-  } else if ((url = '/' + out.path) === '/.') {
-    url = '/'
+  } else {
+    if ((url = '/' + out.path) === '/.') url = '/'
+    if (family === 'alias' && !src.relative) pub.splat = true
+  }
+
+  pub.url = ~url.indexOf(' ') ? url.replace(SPACE_RX, '%20') : url
+
+  if (out) {
+    pub.moduleRootPath = out.moduleRootPath
+    pub.rootPath = out.rootPath
   }
-  pub.url = ~url.indexOf(' ') ? url.replaceAll(' ', '%20') : url
-  return out ? Object.assign(pub, { moduleRootPath: out.moduleRootPath, rootPath: out.rootPath }) : pub
-}
 
-function addSymbolicVersionAlias (componentVersion) {
-  const { name: component, version } = componentVersion
-  const originalVersionSegment = computeVersionSegment.call(this, componentVersion, 'original')
-  const symbolicVersionSegment = computeVersionSegment.call(this, componentVersion, 'alias')
-  if (symbolicVersionSegment === originalVersionSegment || symbolicVersionSegment == null) return
-  const originalVersionSrc = { component, version, versionSegment: originalVersionSegment }
-  const symbolicVersionSrc = { component, version, versionSegment: symbolicVersionSegment }
-  return this.latestVersionSegmentStrategy === 'redirect:to'
-    ? this.addSplatAlias(originalVersionSrc, symbolicVersionSrc)
-    : this.addSplatAlias(symbolicVersionSrc, originalVersionSrc)
+  return pub
 }
 
-function computeVersionSegment (componentVersion, mode) {
-  const version = componentVersion.version
+function computeVersionSegment (name, version, mode) {
   // special designation for master version is @deprecated; special designation scheduled to be removed in Antora 4
-  const normalizedVersion = version && version !== 'master' ? version : ''
-  const { versionSegment = normalizedVersion } = componentVersion
-  if (mode === 'original') return versionSegment
-  const strategy = this.latestVersionSegmentStrategy
-  if (!versionSegment) {
-    if (!mode) return ''
+  if (mode === 'original') return !version || version === 'master' ? '' : version
+  const strategy = this.latestVersionUrlSegmentStrategy
+  if (!version || version === 'master') {
+    if (mode !== 'alias') return ''
     if (strategy === 'redirect:to') return
   }
-  if (strategy === 'redirect:to' || strategy === (mode ? 'redirect:from' : 'replace')) {
-    let component
-    if ((component = 'name' in componentVersion && this.getComponent(componentVersion.name))) {
-      const latestSegment =
+  if (strategy === 'redirect:to' || strategy === (mode === 'alias' ? 'redirect:from' : 'replace')) {
+    const component = this.getComponent(name)
+    const componentVersion = component && this.getComponentVersion(component, version)
+    if (componentVersion) {
+      const segment =
         componentVersion === component.latest
-          ? this.latestVersionSegment
+          ? this.latestVersionUrlSegment
           : componentVersion === component.latestPrerelease
-            ? this.latestPrereleaseVersionSegment
+            ? this.latestPrereleaseVersionUrlSegment
             : undefined
-      return latestSegment == null ? versionSegment : latestSegment
+      return segment == null ? version : segment
     }
   }
-  return versionSegment
-}
-
-function getComponentVersionFiles (componentVersionId) {
-  return this.findBy(componentVersionId)
+  return version
 }
 
-function getComponentVersionStartPage (componentVersionId) {
-  return this.resolvePage('index.adoc', componentVersionId)
-}
-
-function getVersion () {
-  return this.version
+function createSymbolicVersionAlias (component, version, symbolicVersionSegment, strategy) {
+  if (symbolicVersionSegment == null || symbolicVersionSegment === version) return
+  const family = 'alias'
+  const baseVersionAliasSrc = { component, module: 'ROOT', family, relative: '', basename: '', stem: '', extname: '' }
+  const symbolicVersionAliasSrc = Object.assign({}, baseVersionAliasSrc, { version: symbolicVersionSegment })
+  const symbolicVersionAlias = {
+    src: symbolicVersionAliasSrc,
+    pub: computePub(
+      symbolicVersionAliasSrc,
+      computeOut(symbolicVersionAliasSrc, family, symbolicVersionSegment),
+      family
+    ),
+  }
+  const originalVersionAliasSrc = Object.assign({}, baseVersionAliasSrc, { version })
+  const originalVersionSegment = computeVersionSegment(component, version, 'original')
+  const originalVersionAlias = {
+    src: originalVersionAliasSrc,
+    pub: computePub(
+      originalVersionAliasSrc,
+      computeOut(originalVersionAliasSrc, family, originalVersionSegment),
+      family
+    ),
+  }
+  return strategy === 'redirect:to'
+    ? Object.assign(originalVersionAlias, { out: undefined, rel: symbolicVersionAlias })
+    : Object.assign(symbolicVersionAlias, { out: undefined, rel: originalVersionAlias })
 }
 
 module.exports = ContentCatalog

package/lib/util/summarize-file-location.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { posix: path } = require('node:path')
+const { posix: path } = require('path')
 
 function summarizeFileLocation ({ path: path_, src: { abspath, origin } }) {
   if (!origin) return abspath || path_

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antora/content-classifier",
-  "version": "3.1.11",
+  "version": "3.1.12",
   "description": "Organizes aggregated content into a virtual file catalog for use in an Antora documentation pipeline.",
   "license": "MPL-2.0",
   "author": "OpenDevise Inc. (https://opendevise.com)",
@@ -12,8 +12,7 @@
   "homepage": "https://antora.org",
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.com/antora/antora.git",
-    "directory": "packages/content-classifier"
+    "url": "git+https://gitlab.com/antora/antora.git"
   },
   "bugs": {
     "url": "https://gitlab.com/antora/antora/issues"
@@ -31,13 +30,13 @@
     "#constants": "./lib/constants.js"
   },
   "dependencies": {
-    "@antora/asciidoc-loader": "3.1.11",
-    "@antora/logger": "3.1.11",
+    "@antora/asciidoc-loader": "3.1.12",
+    "@antora/logger": "3.1.12",
     "mime-types": "~2.1",
     "vinyl": "~3.0"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=16.0.0"
   },
   "files": [
     "lib/"
@@ -52,7 +51,7 @@
   ],
   "scripts": {
     "test": "_mocha",
-    "prepublishOnly": "npx -y downdoc@latest --prepublish",
-    "postpublish": "npx -y downdoc@latest --postpublish"
+    "prepublishOnly": "npx -y downdoc --prepublish",
+    "postpublish": "npx -y downdoc --postpublish"
   }
 }