Add isFromIncludedArchive flag to references.

Author: mportiz08

src/components/ContentNode.vue

@@ -470,7 +470,7 @@ function renderNode(createElement, references) {
           url: reference.url,
           kind: reference.kind,
           role: reference.role,
-          isActive: node.isActive,
+          isActive: reference.isFromIncludedArchive && node.isActive,
           ideTitle: reference.ideTitle,
           titleStyle: reference.titleStyle,
           hasInlineFormatting: !!titleInlineContent,

src/components/DocumentationTopic/PrimaryContent/DeclarationToken/LinkableToken.vue

@@ -19,7 +19,7 @@ export default {
   render(createElement) {
     const reference = this.references[this.identifier];
     // internal and external link
-    if (reference && reference.url) {
+    if (reference && reference.isFromIncludedArchive && reference.url) {
       return createElement(Reference, {
         props: {
           url: reference.url,

src/mixins/referencesProvider.js

@@ -7,6 +7,7 @@
  * See https://swift.org/LICENSE.txt for license information
  * See https://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
+import AppStore from 'docc-render/stores/AppStore';
 
 export default {
   // inject the `store`
@@ -21,8 +22,37 @@ export default {
       }),
     },
   },
+  data: () => ({ appState: AppStore.state }),
   computed: {
     // exposes the references for the current page
-    references: ({ store }) => store.state.references,
+    references() {
+      const {
+        isFromIncludedArchive,
+        store: {
+          state: { references: originalRefs = {} },
+        },
+      } = this;
+      // if present, use `includedArchiveIdentifiers` data to determine which
+      // references should still be considered active or not
+      return Object.keys(originalRefs).reduce((newRefs, id) => ({
+        ...newRefs,
+        [id]: {
+          ...originalRefs[id],
+          isFromIncludedArchive: isFromIncludedArchive(id),
+        },
+      }), {});
+    },
+  },
+  methods: {
+    isFromIncludedArchive(id) {
+      const { includedArchiveIdentifiers = [] } = this.appState;
+      if (!includedArchiveIdentifiers.length) {
+        return true;
+      }
+
+      return includedArchiveIdentifiers.some(archiveId => (
+        id?.startsWith(`doc://${archiveId}`)
+      ));
+    },
   },
 };

tests/unit/components/ContentNode.spec.js

@@ -9,6 +9,7 @@
 */
 
 import { shallowMount, mount } from '@vue/test-utils';
+import AppStore from 'docc-render/stores/AppStore';
 import Aside from 'docc-render/components/ContentNode/Aside.vue';
 import CodeListing from 'docc-render/components/ContentNode/CodeListing.vue';
 import CodeVoice from 'docc-render/components/ContentNode/CodeVoice.vue';
@@ -1297,6 +1298,43 @@ describe('ContentNode', () => {
       const reference = wrapper.find('.content');
       expect(reference.isEmpty()).toBe(true);
     });
+
+    it('sets `isActive` for included archive content', () => {
+      const foo = {
+        identifier: 'doc://Foo/documentation/foo',
+        title: 'Foo',
+        url: '/documentation/foo',
+      };
+      const mountRef = (props = {}) => mountWithItem({
+        type: 'reference',
+        identifier: foo.identifier,
+        ...props,
+      }, {
+        [foo.identifier]: foo,
+      });
+
+      const wrapper1 = mountRef();
+      const ref1 = wrapper1.find('.content').find(Reference);
+      expect(ref1.exists()).toBe(true);
+      expect(ref1.props('isActive')).toBe(true);
+
+      AppStore.setIncludedArchiveIdentifiers(['Bar']);
+      const wrapper2 = mountRef();
+      const ref2 = wrapper2.find('.content').find(Reference);
+      expect(ref2.exists()).toBe(true);
+      expect(ref2.props('isActive')).toBe(false);
+
+      AppStore.setIncludedArchiveIdentifiers(['Bar', 'Foo']);
+      const wrapper3 = mountRef();
+      const ref3 = wrapper3.find('.content').find(Reference);
+      expect(ref3.exists()).toBe(true);
+      expect(ref3.props('isActive')).toBe(true);
+
+      const wrapper4 = mountRef({ isActive: false });
+      const ref4 = wrapper4.find('.content').find(Reference);
+      expect(ref4.exists()).toBe(true);
+      expect(ref4.props('isActive')).toBe(false);
+    });
   });
 
   describe('with type="strong"', () => {

tests/unit/components/DocumentationTopic/PrimaryContent/DeclarationToken/LinkableToken.spec.js

@@ -9,13 +9,14 @@
 */
 
 import { shallowMount } from '@vue/test-utils';
+import AppStore from 'docc-render/stores/AppStore';
 import LinkableToken
   from 'docc-render/components/DocumentationTopic/PrimaryContent/DeclarationToken/LinkableToken.vue';
 import Reference from 'docc-render/components/ContentNode/Reference.vue';
 
 describe('LinkableToken', () => {
   const foo = {
-    identifier: 'foo',
+    identifier: 'doc://Foo/documentation/foo',
     title: 'Foo',
     url: '/documentation/foo',
   };
@@ -70,4 +71,44 @@ describe('LinkableToken', () => {
     expect(link.props('url')).toBe(foo.url);
     expect(link.text()).toBe(foo.title);
   });
+
+  it('renders a link for references to included archive content', () => {
+    AppStore.setIncludedArchiveIdentifiers(['Foo']);
+    const wrapper = shallowMount(LinkableToken, {
+      ...defaultOpts,
+      provide: {
+        store: {
+          state: {
+            references: {
+              [foo.identifier]: foo,
+            },
+          },
+        },
+      },
+    });
+
+    const link = wrapper.find(Reference);
+    expect(link.exists()).toBe(true);
+    expect(link.props('url')).toBe(foo.url);
+    expect(link.text()).toBe(foo.title);
+  });
+
+  it('renders a span for references to non-included archive content', () => {
+    AppStore.setIncludedArchiveIdentifiers(['Bar']);
+    const wrapper = shallowMount(LinkableToken, {
+      ...defaultOpts,
+      provide: {
+        store: {
+          state: {
+            references: {
+              [foo.identifier]: foo,
+            },
+          },
+        },
+      },
+    });
+
+    expect(wrapper.is('span')).toBe(true);
+    expect(wrapper.text()).toBe(foo.title);
+  });
 });