@antora/content-classifier 3.1.10 → 3.1.11

package/lib/classify-content.js

@@ -10,50 +10,66 @@ const summarizeFileLocation = require('./util/summarize-file-location')
  *
  * @memberof content-classifier
  *
- * @param {Object} playbook - The configuration object for Antora.
+ * @param {Object} playbook - The configuration object for Antora. See ContentCatalog constructor for relevant keys.
  * @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.
- * @returns {ContentCatalog} A structured catalog of content components and virtual content files.
+ * @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.
  */
-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
+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
       const navResolved = nav && (nav.resolved = new Set())
-      componentVersionData.files = undefined // clean up memory
-      files.forEach((file) => allocateSrc(file, name, version, nav) && contentCatalog.addFile(file))
+      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
+      }
       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, name, loc, filepath)
+          logger.warn('Could not resolve nav entry for %s@%s defined in %s: %s', version, component, loc, filepath)
         }
       }
-      contentCatalog.registerComponentVersionStartPage(name, componentVersion, startPage)
-    })
-  contentCatalog.registerSiteStartPage(playbook.site.startPage)
+      contentCatalog.registerComponentVersionStartPage(component, componentVersion, startPage)
+    }
+  }
+  contentCatalog.registerSiteStartPage(siteStartPage)
   return contentCatalog
 }
 
 function allocateSrc (file, component, version, nav) {
-  const extname = file.src.extname
+  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 filepath = file.path
   const pathSegments = filepath.split('/')
   let navInfo
@@ -140,13 +156,19 @@ function getNavInfo (filepath, nav) {
   if (~index) return nav.resolved.add(filepath) && { index }
 }
 
-function resolveAsciiDocConfig (siteAsciiDocConfig, { asciidoc, origins = [] }) {
+function resolveAsciiDocConfig (siteAsciiDocConfig, { name, version, asciidoc, origins = [] }) {
   const scopedAttributes = asciidoc?.attributes
   if (scopedAttributes) {
-    const initial = siteAsciiDocConfig.attributes
+    const initial = Object.assign({}, siteAsciiDocConfig.attributes)
+    initial['antora-component-name'] = name
+    initial['antora-component-version'] = version
     const mdc = { file: { path: 'antora.yml', origin: origins[origins.length - 1] } }
     const attributes = collateAsciiDocAttributes(scopedAttributes, { initial, mdc, merge: true })
-    if (attributes !== initial) siteAsciiDocConfig = Object.assign({}, siteAsciiDocConfig, { attributes })
+    if (attributes !== initial) {
+      delete attributes['antora-component-name']
+      delete attributes['antora-component-version']
+      return Object.assign({}, siteAsciiDocConfig, { attributes })
+    }
   }
   return siteAsciiDocConfig
 }

package/lib/content-catalog.js

@@ -5,13 +5,12 @@ 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('path')
+const { posix: path } = require('node: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')
@@ -24,17 +23,17 @@ class ContentCatalog {
     const urls = playbook.urls || {}
     this.htmlUrlExtensionStyle = urls.htmlExtensionStyle || 'default'
     this.urlRedirectFacility = urls.redirectFacility || 'static'
-    this.latestVersionUrlSegment = urls.latestVersionSegment
-    this.latestPrereleaseVersionUrlSegment = urls.latestPrereleaseVersionSegment
-    if (this.latestVersionUrlSegment == null && this.latestPrereleaseVersionUrlSegment == null) {
-      this.latestVersionUrlSegmentStrategy = undefined
+    this.latestVersionSegment = urls.latestVersionSegment
+    this.latestPrereleaseVersionSegment = urls.latestPrereleaseVersionSegment
+    if (this.latestVersionSegment == null && this.latestPrereleaseVersionSegment == null) {
+      this.latestVersionSegmentStrategy = undefined
     } else {
-      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
+      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
         }
       }
     }
@@ -43,6 +42,8 @@ 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.
@@ -59,8 +60,9 @@ class ContentCatalog {
    * @returns {Object} The constructed component version object.
    */
   registerComponentVersion (name, version, descriptor = {}) {
-    const { asciidoc, displayVersion, prerelease, startPage: startPageSpec, title } = descriptor
+    const { asciidoc, displayVersion, prerelease, startPage: startPageSpec, title, versionSegment } = 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
@@ -129,14 +131,15 @@ 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) {
+  addFile (file, componentVersion) {
     const src = file.src
-    let family = src.family
+    let { component, version, family } = src
     let filesForFamily = this[$files].get(family)
     if (!filesForFamily) this[$files].set(family, (filesForFamily = new Map()))
     const key = generateKey(src)
@@ -148,30 +151,30 @@ class ContentCatalog {
         .map((it, idx) => `${idx + 1}: ${summarizeFileLocation(it)}`)
         .join(LOG_WRAP)
       if (family === 'nav') {
-        throw new Error(`Duplicate nav in ${src.version}@${src.component}: ${file.path}${LOG_WRAP}${details}`)
+        throw new Error(`Duplicate nav file: ${file.path} in ${version}@${component}${LOG_WRAP}${details}`)
       }
       throw new Error(`Duplicate ${family}: ${generateResourceSpec(src)}${LOG_WRAP}${details}`)
     }
-    // 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
+    // NOTE: 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
-    //if (!src.path) prepareSrc(src)
-    //if (!File.isVinyl(file)) file = new File(file)
+    // an alternate approach would be to call prepareSrc if the path property is not set
     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
-      // QUESTION: should we preserve the mediaType property on file if already defined?
+      // 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?
       file.mediaType = src.mediaType = resolveMimeType(src.extname) || (family === 'page' ? 'text/asciidoc' : undefined)
     }
     let publishable
-    let versionSegment
+    let activeVersionSegment
     if (file.out) {
       publishable = true
     } else if ('out' in file) {
@@ -181,15 +184,24 @@ class ContentCatalog {
       ('/' + src.relative).indexOf('/_') < 0
     ) {
       publishable = true
-      versionSegment = computeVersionSegment.call(this, src.component, src.version)
-      file.out = computeOut(src, family, versionSegment, this.htmlUrlExtensionStyle)
+      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)
     }
     if (!file.pub && (publishable || family === 'nav')) {
-      if (versionSegment == null) versionSegment = computeVersionSegment.call(this, src.component, src.version)
-      file.pub = computePub(src, file.out, family, versionSegment, this.htmlUrlExtensionStyle)
+      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)
     }
-    filesForFamily.set(key, file)
-    return file
+    return filesForFamily.set(key, file) && file
   }
 
   removeFile (file) {
@@ -266,38 +278,48 @@ class ContentCatalog {
 
   // TODO add `follow` argument to control whether alias is followed
   getSiteStartPage () {
-    return this.getById(ROOT_INDEX_PAGE_ID) || this.getById(ROOT_INDEX_ALIAS_ID)?.rel
+    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
   }
 
   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(name, componentVersion))) return
+      if (!(componentVersion = this.getComponentVersion(component, componentVersion))) return
       version = componentVersion.version
     }
+    const activeVersionSegment = computeVersionSegment.call(this, componentVersion)
     let startPage
     let startPageSrc
-    const indexPageId = Object.assign({}, ROOT_INDEX_PAGE_ID, { component: name, version })
+    const indexPageId = Object.assign({}, ROOT_INDEX_PAGE_ID, { component, version })
     if (startPageSpec) {
       if (
         (startPage = this.resolvePage(startPageSpec, indexPageId)) &&
-        (startPageSrc = startPage.src).component === name &&
+        (startPageSrc = startPage.src).component === component &&
         startPageSrc.version === version
       ) {
         if (!this.getById(indexPageId)) {
-          const indexAliasId = Object.assign({}, ROOT_INDEX_ALIAS_ID, { component: name, version })
+          const indexAliasId = Object.assign({}, ROOT_INDEX_ALIAS_ID, { component, version })
           const indexAlias = this.getById(indexAliasId)
           indexAlias
             ? indexAlias.synthetic && Object.assign(indexAlias, { rel: startPage })
-            : this.addFile({ src: indexAliasId, rel: startPage, synthetic: true })
+            : this.addFile({ src: indexAliasId, rel: startPage, synthetic: true }, componentVersion)
         }
       } else {
         // TODO pass componentVersion as logObject
         logger.warn(
           'Start page specified for %s@%s %s: %s',
           version,
-          name,
+          component,
           startPage === false ? 'has invalid syntax' : 'not found',
           startPageSpec
         )
@@ -308,25 +330,34 @@ class ContentCatalog {
     }
     if (startPage) {
       componentVersion.url = startPage.pub.url
-    } else {
+    } else if (!componentVersion.url) {
       // 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, versionSegment, this.htmlUrlExtensionStyle),
+        computeOut(startPageSrc, startPageSrc.family, activeVersionSegment, this.htmlUrlExtensionStyle),
         startPageSrc.family,
-        versionSegment,
+        activeVersionSegment,
         this.htmlUrlExtensionStyle
       ).url
     }
-
-    const symbolicVersionAlias = createSymbolicVersionAlias(
-      name,
-      version,
-      computeVersionSegment.call(this, name, version, 'alias'),
-      this.latestVersionUrlSegmentStrategy
-    )
-    if (symbolicVersionAlias) this.addFile(symbolicVersionAlias)
+    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
   }
 
   registerSiteStartPage (startPageSpec) {
@@ -334,9 +365,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 })
     }
@@ -357,9 +388,14 @@ 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 = component.latest.version
+      if (src.version == null) {
+        src.version = (componentVersion = component.latest).version
+      } else {
+        componentVersion = this.getComponentVersion(component, src.version)
+      }
       const existingPage = this.getById(src)
       if (existingPage) {
         throw new Error(
@@ -384,33 +420,77 @@ class ContentCatalog {
       )
     }
     // NOTE the redirect producer will populate contents when the redirect facility is 'static'
-    const alias = this.addFile({ src, rel: target })
+    const alias = this.addFile({ src, rel: target }, componentVersion)
     // NOTE record the first alias this target claims as the preferred one
     if (!target.rel) target.rel = alias
     return alias
   }
 
   /**
-   * Attempts to resolve a string contextual page ID spec to a file in the catalog.
+   * 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.
    *
-   * Parses the specified contextual page ID spec into a page ID object, then attempts to lookup a
-   * file with this page ID in the catalog. If a component is specified, but not a version, the
-   * latest version of the component stored in the catalog is used. If a page cannot be resolved,
-   * the search is attempted again for an "alias". If neither a page or alias can be resolved, the
-   * function returns undefined. If the spec does not match the page ID syntax, this function throws
-   * an error.
+   * Parses the specified page reference (i.e., page ID spec) into a partial page ID, expands it
+   * using the provided context, then attempts to locate a file in the page family with that page ID
+   * in this catalog. The family segment is optional.
    *
-   * @param {String} spec - The contextual page ID spec (e.g., version@component:module:topic/page.adoc).
-   * @param {ContentCatalog} catalog - The content catalog in which to resolve the page file.
-   * @param {Object} [ctx={}] - The context to use to qualified the contextual page ID.
+   * If a component is specified, but no version, the latest version of the component stored in the
+   * catalog is used. If a page cannot be resolved, the search is attempted again for an "alias". If
+   * neither a page or alias can be resolved, the function returns undefined. If the syntax of the
+   * reference is invalid, this function throws an error.
    *
-   * @returns {File} The virtual file to which the contextual page ID spec refers, or undefined if the
-   * file cannot be resolved.
+   * @param {String} spec - The contextual page reference (e.g., version@component:module:topic/page.adoc).
+   * @param {Object} [context={}] - The context to use to qualify the page reference.
+   *
+   * @returns {File} The virtual file to which the contextual page reference resolves, or undefined
+   * if the file cannot be resolved.
    */
   resolvePage (spec, context = {}) {
     return this.resolveResource(spec, context, 'page', ['page'])
   }
 
+  /**
+   * Attempts to resolve a resource reference within the given context to a file in the catalog.
+   *
+   * Parses the specified resource reference (i.e., resource ID spec) into a partial resource ID,
+   * expands it using the provided context, then attempts to locate a file with that resource ID in
+   * this catalog.
+   *
+   * If a component is specified, but no version, the latest version of the component stored in the
+   * catalog is used. If a defaultFamily is not specified, the family must be specified either by
+   * the reference or the context. If permittedFamilies are stated, the family must resolve to a
+   * family in this list. If a file cannot be resolved, the function returns undefined. If the
+   * syntax of the reference is invalid, this function throws an error.
+   *
+   * @param {String} spec - The contextual resource reference (e.g., version@component:module:image$topic/image.png).
+   * @param {Object} [context={}] - The context to use to qualify the resource reference.
+   * @param {String} [defaultFamily=undefined] - The default family to use if one is not provided.
+   * @param {Array<String>} [permittedFamilies=undefined] - A list of families that are permitted.
+   *
+   * @returns {File} The virtual file to which the contextual resource reference resolves, or
+   * undefined if the file cannot be resolved.
+   */
   resolveResource (spec, context = {}, defaultFamily = undefined, permittedFamilies = undefined) {
     return resolveResource(spec, this, context, defaultFamily, permittedFamilies)
   }
@@ -452,32 +532,28 @@ function generateResourceSpec ({ component, version, module: module_, family, re
 
 function prepareSrc (src) {
   let { basename, extname, stem } = src
-  let update
   if (basename == null) {
-    update = true
-    basename = path.basename(src.relative)
+    basename = src.basename = path.basename(src.relative)
   }
   if (stem == null) {
-    update = true
     if (extname == null) {
       if (~(extname = basename.lastIndexOf('.'))) {
-        stem = basename.substr(0, extname)
-        extname = basename.substr(extname)
+        src.stem = basename.substr(0, extname)
+        src.extname = basename.substr(extname)
       } else {
-        stem = basename
-        extname = ''
+        src.stem = basename
+        src.extname = ''
       }
     } else {
-      stem = basename.substr(0, basename.length - extname.length)
+      src.stem = basename.substr(0, basename.length - extname.length)
     }
   } else if (extname == null) {
-    update = true
-    extname = basename.substr(stem.length)
+    src.extname = basename.substr(stem.length)
   }
-  return update ? Object.assign(src, { basename, extname, stem }) : src
+  return src
 }
 
-function computeOut (src, family, version, htmlUrlExtensionStyle) {
+function computeOut (src, family, versionSegment, htmlUrlExtensionStyle) {
   let { component, module: module_, basename, extname, relative, stem } = src
   if (component === 'ROOT') component = ''
   if (module_ === 'ROOT') module_ = ''
@@ -497,7 +573,7 @@ function computeOut (src, family, version, htmlUrlExtensionStyle) {
     familyPathSegment = '_attachments'
   }
 
-  const modulePath = path.join(component, version, module_)
+  const modulePath = path.join(component, versionSegment, module_)
   const dirname = path.join(modulePath, familyPathSegment, path.dirname(relative), indexifyPathSegment)
   const path_ = path.join(dirname, basename)
   const moduleRootPath = path.relative(dirname, modulePath) || '.'
@@ -506,13 +582,13 @@ function computeOut (src, family, version, htmlUrlExtensionStyle) {
   return { dirname, basename, path: path_, moduleRootPath, rootPath }
 }
 
-function computePub (src, out, family, version, htmlUrlExtensionStyle) {
+function computePub (src, out, family, versionSegment, htmlUrlExtensionStyle) {
   const pub = {}
   let url
   if (family === 'nav') {
     const component = src.component || 'ROOT'
     const urlSegments = component === 'ROOT' ? [] : [component]
-    if (version) urlSegments.push(version)
+    if (versionSegment) urlSegments.push(versionSegment)
     const module_ = src.module || 'ROOT'
     if (module_ !== 'ROOT') urlSegments.push(module_)
     if (urlSegments.length) urlSegments.push('')
@@ -531,71 +607,61 @@ function computePub (src, out, family, version, htmlUrlExtensionStyle) {
       urlSegments[lastUrlSegmentIdx] = ''
     }
     url = '/' + urlSegments.join('/')
-  } 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
+  } else if ((url = '/' + out.path) === '/.') {
+    url = '/'
   }
+  pub.url = ~url.indexOf(' ') ? url.replaceAll(' ', '%20') : url
+  return out ? Object.assign(pub, { moduleRootPath: out.moduleRootPath, rootPath: out.rootPath }) : pub
+}
 
-  return 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)
 }
 
-function computeVersionSegment (name, version, mode) {
+function computeVersionSegment (componentVersion, mode) {
+  const version = componentVersion.version
   // special designation for master version is @deprecated; special designation scheduled to be removed in Antora 4
-  if (mode === 'original') return !version || version === 'master' ? '' : version
-  const strategy = this.latestVersionUrlSegmentStrategy
-  if (!version || version === 'master') {
-    if (mode !== 'alias') return ''
+  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 (strategy === 'redirect:to') return
   }
-  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 =
+  if (strategy === 'redirect:to' || strategy === (mode ? 'redirect:from' : 'replace')) {
+    let component
+    if ((component = 'name' in componentVersion && this.getComponent(componentVersion.name))) {
+      const latestSegment =
         componentVersion === component.latest
-          ? this.latestVersionUrlSegment
+          ? this.latestVersionSegment
           : componentVersion === component.latestPrerelease
-            ? this.latestPrereleaseVersionUrlSegment
+            ? this.latestPrereleaseVersionSegment
             : undefined
-      return segment == null ? version : segment
+      return latestSegment == null ? versionSegment : latestSegment
     }
   }
-  return version
+  return versionSegment
 }
 
-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 })
+function getComponentVersionFiles (componentVersionId) {
+  return this.findBy(componentVersionId)
+}
+
+function getComponentVersionStartPage (componentVersionId) {
+  return this.resolvePage('index.adoc', componentVersionId)
+}
+
+function getVersion () {
+  return this.version
 }
 
 module.exports = ContentCatalog

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { posix: path } = require('path')
+const { posix: path } = require('node: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.10",
+  "version": "3.1.11",
   "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,7 +12,8 @@
   "homepage": "https://antora.org",
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.com/antora/antora.git"
+    "url": "git+https://gitlab.com/antora/antora.git",
+    "directory": "packages/content-classifier"
   },
   "bugs": {
     "url": "https://gitlab.com/antora/antora/issues"
@@ -30,13 +31,13 @@
     "#constants": "./lib/constants.js"
   },
   "dependencies": {
-    "@antora/asciidoc-loader": "3.1.10",
-    "@antora/logger": "3.1.10",
+    "@antora/asciidoc-loader": "3.1.11",
+    "@antora/logger": "3.1.11",
     "mime-types": "~2.1",
     "vinyl": "~3.0"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
     "lib/"
@@ -51,7 +52,7 @@
   ],
   "scripts": {
     "test": "_mocha",
-    "prepublishOnly": "npx -y downdoc --prepublish",
-    "postpublish": "npx -y downdoc --postpublish"
+    "prepublishOnly": "npx -y downdoc@latest --prepublish",
+    "postpublish": "npx -y downdoc@latest --postpublish"
   }
 }