@antora/content-classifier 3.1.2 → 3.2.0-alpha.2

package/README.md

@@ -9,4 +9,4 @@ Its site generator aggregates documents from versioned content repositories and
 
 Copyright (C) 2017-present [OpenDevise Inc.](https://opendevise.com) and the [Antora Project](https://antora.org).
 
-Use of this software is granted under the terms of the [Mozilla Public License Version 2.0](https://www.mozilla.org/en-US/MPL/2.0/) (MPL-2.0).
+Use of this software is granted under the terms of the [Mozilla Public License Version 2.0](https://www.mozilla.org/en-US/MPL/2.0/) (MPL-2.0).

package/lib/classify-content.js

@@ -8,42 +8,58 @@ const collateAsciiDocAttributes = require('@antora/asciidoc-loader/config/collat
  *
  * @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
-      componentVersionData.files = undefined // clean up memory
-      files.forEach((file) => allocateSrc(file, name, version, nav) && contentCatalog.addFile(file))
-      contentCatalog.registerComponentVersionStartPage(name, componentVersion, startPage)
+function classifyContent (playbook, aggregate, siteAsciiDocConfig = {}, onComponentsRegistered) {
+  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),
     })
-  contentCatalog.registerSiteStartPage(playbook.site.startPage)
+    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
+      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
+      }
+      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 navInfo = nav && getNavInfo(filepath, nav)
   const pathSegments = filepath.split('/')

package/lib/content-catalog.js

@@ -23,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
         }
       }
     }
@@ -42,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.
@@ -58,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
@@ -127,14 +130,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)
@@ -146,7 +150,7 @@ class ContentCatalog {
           .map((it, idx) => `${idx + 1}: ${getFileLocation(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 in ${version}@${component}: ${file.path}${LOG_WRAP}${details}`)
         } else {
           throw new Error(`Duplicate ${family}: ${generateResourceSpec(src)}${LOG_WRAP}${details}`)
         }
@@ -162,16 +166,18 @@ class ContentCatalog {
       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 +187,18 @@ 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 = 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 = 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) {
@@ -267,38 +276,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
         )
@@ -309,25 +328,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) {
@@ -335,9 +363,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 })
     } else if (rel === false) {
@@ -357,9 +385,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,12 +417,34 @@ 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
   }
 
+  /**
+   * 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 string contextual page ID spec to a file in the catalog.
    *
@@ -477,7 +532,7 @@ function prepareSrc (src) {
   return update ? Object.assign(src, { basename, extname, stem }) : 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 +552,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 +561,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 +586,49 @@ 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
+  } else if ((url = '/' + out.path) === '/.') {
+    url = '/'
   }
-
   pub.url = ~url.indexOf(' ') ? url.replace(SPACE_RX, '%20') : url
+  return out ? Object.assign(pub, { moduleRootPath: out.moduleRootPath, rootPath: out.rootPath }) : pub
+}
 
-  if (out) {
-    pub.moduleRootPath = out.moduleRootPath
-    pub.rootPath = out.rootPath
-  }
-
-  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 verson 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
-}
-
-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 })
+  return versionSegment
 }
 
 function getFileLocation ({ path: path_, src: { abspath, origin } }) {
@@ -607,4 +640,16 @@ function getFileLocation ({ path: path_, src: { abspath, origin } }) {
   return `${abspath || path.join(startPath, path_)} in ${'worktree' in origin ? worktree || gitdir : url} (${details})`
 }
 
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antora/content-classifier",
-  "version": "3.1.2",
+  "version": "3.2.0-alpha.2",
   "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)",
@@ -27,8 +27,8 @@
     "#constants": "./lib/constants.js"
   },
   "dependencies": {
-    "@antora/asciidoc-loader": "3.1.2",
-    "@antora/logger": "3.1.2",
+    "@antora/asciidoc-loader": "3.2.0-alpha.2",
+    "@antora/logger": "3.2.0-alpha.2",
     "mime-types": "~2.1",
     "vinyl": "~2.2"
   },