From 74235937394cec9296e8e83043ead11c9eb0e971 Mon Sep 17 00:00:00 2001
From: "Jurriaan H. Spaaks" <j.spaaks@esciencecenter.nl>
Date: Fri, 25 Nov 2022 20:28:47 +0100
Subject: [PATCH] reinstated eslint max-len rule refs #42; consolidated some
 types refs #46; harmonized the casing of the FAIR letters

---
 .eslintrc.json                          |   1 -
 pages/data/v0.1/BannerVersions.vue      |   4 +-
 pages/data/v0.1/ChecklistHeader.vue     |  15 +-
 pages/data/v0.1/index.page.vue          |  26 ++-
 pages/data/v0.1/questions.json          | 146 ++++++++---------
 pages/data/v0.1/questions.test.ts       |  16 +-
 pages/data/v0.1/schema.json             |   8 +-
 pages/data/v0.1/store.ts                |  64 ++++----
 pages/data/v0.1/types.ts                |  16 ++
 pages/index/ChecklistFooter.vue         |   3 +-
 pages/index/index.page.vue              |   4 +-
 pages/software/v0.1/BannerParams.vue    |   4 +-
 pages/software/v0.1/BannerVersions.vue  |   4 +-
 pages/software/v0.1/ChecklistHeader.vue |  15 +-
 pages/software/v0.1/index.page.vue      |  26 ++-
 pages/software/v0.1/questions.json      | 208 ++++++++++++------------
 pages/software/v0.1/questions.test.ts   |  16 +-
 pages/software/v0.1/schema.json         |   8 +-
 pages/software/v0.1/store.ts            |  64 ++++----
 pages/software/v0.1/types.ts            |  16 ++
 20 files changed, 370 insertions(+), 294 deletions(-)
 create mode 100644 pages/data/v0.1/types.ts
 create mode 100644 pages/software/v0.1/types.ts

diff --git a/.eslintrc.json b/.eslintrc.json
index 46a3395..84ac4ba 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -39,7 +39,6 @@
         "import/no-extraneous-dependencies": ["error", { "devDependencies": ["**/*.test.ts"] }],
         "import/no-unresolved": ["off"],
         "indent": ["error", 4],
-        "max-len": ["off"],
         "object-curly-newline": ["error", { "multiline": true }]
     }
 }
diff --git a/pages/data/v0.1/BannerVersions.vue b/pages/data/v0.1/BannerVersions.vue
index feca72a..dc79111 100644
--- a/pages/data/v0.1/BannerVersions.vue
+++ b/pages/data/v0.1/BannerVersions.vue
@@ -1,6 +1,8 @@
 <template>
     <div class="banner" v-if="showBanner">
-        A newer version of this checklist is available at <ChecklistLink v-bind:href="link">{{link}}</ChecklistLink>, consider upgrading.
+        A newer version of this checklist is available at
+        <ChecklistLink v-bind:href="link">{{link}}</ChecklistLink>
+        , consider upgrading.
     </div>
 </template>
 
diff --git a/pages/data/v0.1/ChecklistHeader.vue b/pages/data/v0.1/ChecklistHeader.vue
index cb9cb54..1924997 100644
--- a/pages/data/v0.1/ChecklistHeader.vue
+++ b/pages/data/v0.1/ChecklistHeader.vue
@@ -17,13 +17,22 @@
                     <g
                     id="outline"
                     transform="matrix(1.032058,0,0,1.032058,-2.0517123,-5.997519)">
-                    <path d="m 64,13.845703 -57.4746094,41.068359 4.6894534,6.5625 7.96289,-5.689453 V 121.80078 H 49.626953 V 91.585938 H 65.746094 V 121.80078 H 108.82227 V 55.787109 l 7.96289,5.689453 4.68945,-6.5625 C 114.12178,49.660112 106.76885,44.406295 99.416016,39.152344 V 17.582031 H 83.607422 V 27.855469 C 77.071721,23.185398 70.535701,18.515774 64,13.845703 Z m 0,15.738281 34.822266,24.882813 V 111.80078 H 75.746094 V 81.585938 H 39.626953 V 111.80078 H 29.177734 V 54.466797 Z" />
+                    <path d="m 64,13.845703 -57.4746094,41.068359 4.6894534,6.5625
+                            7.96289,-5.689453 V 121.80078 H 49.626953 V 91.585938
+                            H 65.746094 V 121.80078 H 108.82227 V 55.787109 l
+                            7.96289,5.689453 4.68945,-6.5625 C 114.12178,49.660112
+                            106.76885,44.406295 99.416016,39.152344 V 17.582031 H
+                            83.607422 V 27.855469 C 77.071721,23.185398 70.535701,18.515774
+                            64,13.845703 Z m 0,15.738281 34.822266,24.882813 V 111.80078
+                            H 75.746094 V 81.585938 H 39.626953 V 111.80078 H 29.177734
+                            V 54.466797 Z" />
                     <g>
                         <path d="m 89.706841,22.049501 h 5.808742 v 12.368457 h -5.808742 z" />
                     </g>
                     </g>
-                    <path
-                    d="M 63.999995,24.525796 99.938597,50.206302 V 109.3783 H 76.122651 V 78.194827 H 38.845604 V 109.3783 H 28.061403 V 50.206302 Z"
+                    <path d="M 63.999995,24.525796 99.938597,50.206302 V 109.3783 H
+                        76.122651 V 78.194827 H 38.845604 V 109.3783 H 28.061403 V
+                        50.206302 Z"
                     id="inside" />
                 </g>
                 </svg>
diff --git a/pages/data/v0.1/index.page.vue b/pages/data/v0.1/index.page.vue
index 76e46d8..12fa8d1 100644
--- a/pages/data/v0.1/index.page.vue
+++ b/pages/data/v0.1/index.page.vue
@@ -6,10 +6,16 @@
             <h1>FAIR for data self-assessment checklist</h1>
             <BannerVersions />
             <template v-if="nQuestions.total > 0">
-                <p>Answer the {{ nQuestions.total }} questions below to assess your data's FAIRness, or switch to the checklist for <ChecklistLink v-bind:href="linkToSoftwareChecklist">software</ChecklistLink> instead.</p>
-                <div v-for="aspect in ['F', 'A', 'I', 'R']" v-bind:key="aspect">
+                <p>
+                    Answer the {{ nQuestions.total }} questions below to assess
+                    your data's FAIRness, or switch to the checklist for
+                    <ChecklistLink v-bind:href="linkToSoftwareChecklist">software</ChecklistLink>
+                    instead.
+                </p>
+                <div v-for="aspect in aspects" v-bind:key="aspect">
                     <h2>{{ getAspectFullname(aspect) }}</h2>
-                    <ChecklistQuestion v-for="question in questions.filter(q => q.aspect === aspect)"
+                    <ChecklistQuestion
+                        v-for="question in questions.filter(q => q.aspect === aspect)"
                         v-bind:key="question.id"
                         v-bind:question="question"
                     />
@@ -28,12 +34,14 @@
 
 <script setup lang="ts">
 import { latest } from '~/renderer/versions';
+import { aspects } from './store';
 import { nQuestions } from './store';
 import { progress } from './store';
 import { questions } from './store';
 import { questions as data } from './questions.json';
 import { setQuestions } from './store';
-import { type QuestionType } from './store';
+import { type Aspect } from './types';
+import { type QuestionType } from './types';
 import ChecklistAbout from './ChecklistAbout.vue';
 import BannerVersions from './BannerVersions.vue';
 import ChecklistHeader from './ChecklistHeader.vue';
@@ -45,11 +53,11 @@ import './app.css';
 
 setQuestions(data as QuestionType[]);
 
-const getAspectFullname = (aspect: string) => ({
-    F: 'Findable',
-    A: 'Accessible',
-    I: 'Interoperable',
-    R: 'Reusable'
+const getAspectFullname = (aspect: Aspect) => ({
+    f: 'Findable',
+    a: 'Accessible',
+    i: 'Interoperable',
+    r: 'Reusable'
 }[aspect]);
 const linkToSoftwareChecklist = `${import.meta.env.BASE_URL}software/${latest.value.software}`;
 </script>
diff --git a/pages/data/v0.1/questions.json b/pages/data/v0.1/questions.json
index 71a44f8..37dd8ab 100644
--- a/pages/data/v0.1/questions.json
+++ b/pages/data/v0.1/questions.json
@@ -3,353 +3,353 @@
         {
             "answers": [
                 {
-                    "id": "F:q0:a0",
+                    "id": "f:q0:a0",
                     "score": 0,
                     "text": "No identifier"
                 },
                 {
-                    "id": "F:q0:a1",
+                    "id": "f:q0:a1",
                     "score": 1,
                     "text": "Local identifier"
                 },
                 {
-                    "id": "F:q0:a2",
+                    "id": "f:q0:a2",
                     "score": 3,
                     "text": "Web address (URL)"
                 },
                 {
-                    "id": "F:q0:a3",
+                    "id": "f:q0:a3",
                     "score": 8,
                     "text": "Globally Unique, citable and persistent (e.g. DOI, PURL, ARK or Handle)"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "",
-            "id": "F:q0",
+            "id": "f:q0",
             "principle": "",
             "text": "Does the dataset have any identifiers assigned?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q1:a0",
+                    "id": "f:q1:a0",
                     "score": 0,
                     "text": "No"
                 },
                 {
-                    "id": "F:q1:a1",
+                    "id": "f:q1:a1",
                     "score": 1,
                     "text": "Yes"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "",
-            "id": "F:q1",
+            "id": "f:q1",
             "principle": "",
             "text": "Is the dataset identifier included in all metadata records/files describing the data?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q2:a0",
+                    "id": "f:q2:a0",
                     "score": 0,
                     "text": "The data is not described."
                 },
                 {
-                    "id": "F:q2:a1",
+                    "id": "f:q2:a1",
                     "score": 2,
                     "text": "Brief title and description."
                 },
                 {
-                    "id": "F:q2:a2",
+                    "id": "f:q2:a2",
                     "score": 3,
                     "text": "Comprehensively, but in a text-based, non-standard format."
                 },
                 {
-                    "id": "F:q2:a3",
+                    "id": "f:q2:a3",
                     "score": 4,
                     "text": "Comprehensively (see suggestion) using a recognised formal machine-readable metadata schema."                                                                                                                    
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "",
-            "id": "F:q2",
+            "id": "f:q2",
             "principle": "",
             "text": "How is the data described with metadata?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q3:a0",
+                    "id": "f:q3:a0",
                     "score": 0,
                     "text": "The data is not described in any repository"
                 },
                 {
-                    "id": "F:q3:a1",
+                    "id": "f:q3:a1",
                     "score": 2,
                     "text": "Local institutional repository"
                 },
                 {
-                    "id": "F:q3:a2",
+                    "id": "f:q3:a2",
                     "score": 2,
                     "text": "Domain-specific repository"
                 },
                 {
-                    "id": "F:q3:a3",
+                    "id": "f:q3:a3",
                     "score": 2,
                     "text": "Generalist public repository"
                 },
                 {
-                    "id": "F:q3:a4",
+                    "id": "f:q3:a4",
                     "score": 4,
                     "text": "Data is in one place but discoverable through several registries"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "",
-            "id": "F:q3",
+            "id": "f:q3",
             "principle": "",
             "text": "What type of repository or registry is the metadata record in?"
         },
         {
             "answers": [
                 {
-                    "id": "A:q0:a0",
+                    "id": "a:q0:a0",
                     "score": 0,
                     "text": "No access to data or metadata"
                 },
                 {
-                    "id": "A:q0:a1",
+                    "id": "a:q0:a1",
                     "score": 1,
                     "text": "Access to metadata only"
                 },
                 {
-                    "id": "A:q0:a2",
+                    "id": "a:q0:a2",
                     "score": 2,
                     "text": "Unspecified conditional access e.g. contact the data custodian for access"
                 },
                 {
-                    "id": "A:q0:a3",
+                    "id": "a:q0:a3",
                     "score": 3,
                     "text": "Embargoed access after a specified date"
                 },
                 {
-                    "id": "A:q0:a4",
+                    "id": "a:q0:a4",
                     "score": 4,
                     "text": "A de-identified / modified subset of the data is publicly accessible"
                 },
                 {
-                    "id": "A:q0:a5",
+                    "id": "a:q0:a5",
                     "score": 5,
                     "text": "Fully accessible to persons who meet explicitly stated conditions, e.g. ethics approval for sensitive data"                                                                                                      
                 },
                 {
-                    "id": "A:q0:a6",
+                    "id": "a:q0:a6",
                     "score": 5,
                     "text": "Publicly accessible"
                 }
             ],
-            "aspect": "A",
+            "aspect": "a",
             "guidance": "",
-            "id": "A:q0",
+            "id": "a:q0",
             "principle": "",
             "text": "How accessible is the data?"
         },
         {
             "answers": [
                 {
-                    "id": "A:q1:a0",
+                    "id": "a:q1:a0",
                     "score": 0,
                     "text": "No access to data"
                 },
                 {
-                    "id": "A:q1:a1",
+                    "id": "a:q1:a1",
                     "score": 1,
                     "text": "By individual arrangement"
                 },
                 {
-                    "id": "A:q1:a2",
+                    "id": "a:q1:a2",
                     "score": 2,
                     "text": "File download from online location"
                 },
                 {
-                    "id": "A:q1:a3",
+                    "id": "a:q1:a3",
                     "score": 3,
                     "text": "Non-standard web service (e.g. OpenAPI/Swagger/informal API)"
                 },
                 {
-                    "id": "A:q1:a4",
+                    "id": "a:q1:a4",
                     "score": 4,
                     "text": "Standard web service API (e.g. OGC)"
                 }
             ],
-            "aspect": "A",
+            "aspect": "a",
             "guidance": "",
-            "id": "A:q1",
+            "id": "a:q1",
             "principle": "",
             "text": "Is the data available online without requiring specialised protocols or tools once access has been approved?"                                                                                                            
         },
         {
             "answers": [
                 {
-                    "id": "A:q2:a0",
+                    "id": "a:q2:a0",
                     "score": 0,
                     "text": "No"
                 },
                 {
-                    "id": "A:q2:a1",
+                    "id": "a:q2:a1",
                     "score": 0,
                     "text": "Unsure"
                 },
                 {
-                    "id": "A:q2:a2",
+                    "id": "a:q2:a2",
                     "score": 1,
                     "text": "Yes"
                 }
             ],
-            "aspect": "A",
+            "aspect": "a",
             "guidance": "",
-            "id": "A:q2",
+            "id": "a:q2",
             "principle": "",
             "text": "Will the metadata record be available even if the data is no longer available?"
         },
         {
             "answers": [
                 {
-                    "id": "I:q0:a0",
+                    "id": "i:q0:a0",
                     "score": 0,
                     "text": "Mostly in a proprietary format"
                 },
                 {
-                    "id": "I:q0:a1",
+                    "id": "i:q0:a1",
                     "score": 1,
                     "text": "In a structured, open standard, non-machine-readable format"
                 },
                 {
-                    "id": "I:q0:a2",
+                    "id": "i:q0:a2",
                     "score": 2,
                     "text": "In a structured, open standard, machine-readable format"
                 }
             ],
-            "aspect": "I",
+            "aspect": "i",
             "guidance": "",
-            "id": "I:q0",
+            "id": "i:q0",
             "principle": "",
             "text": "What (file) format(s) is the data available in?"
         },
         {
             "answers": [
                 {
-                    "id": "I:q1:a0",
+                    "id": "i:q1:a0",
                     "score": 0,
                     "text": "Data elements not described"
                 },
                 {
-                    "id": "I:q1:a1",
+                    "id": "i:q1:a1",
                     "score": 1,
                     "text": "No standards have been applied in the description of data elements"
                 },
                 {
-                    "id": "I:q1:a2",
+                    "id": "i:q1:a2",
                     "score": 2,
                     "text": "Standardised vocabularies/ontologies/schema without global identifiers"
                 },
                 {
-                    "id": "I:q1:a3",
+                    "id": "i:q1:a3",
                     "score": 3,
                     "text": "Standardised open and universal using resolvable global identifiers linking to explanations"                                                                                                                     
                 }
             ],
-            "aspect": "I",
+            "aspect": "i",
             "guidance": "",
-            "id": "I:q1",
+            "id": "i:q1",
             "principle": "",
             "text": "What best describes the types of vocabularies/ontologies/tagging schemas used to define the data elements?"                                                                                                              
         },
         {
             "answers": [
                 {
-                    "id": "I:q2:a0",
+                    "id": "i:q2:a0",
                     "score": 0,
                     "text": "There are no links to other metadata"
                 },
                 {
-                    "id": "I:q2:a1",
+                    "id": "i:q2:a1",
                     "score": 2,
                     "text": "The metadata record includes URI links to related metadata, data and definitions"
                 },
                 {
-                    "id": "I:q2:a2",
+                    "id": "i:q2:a2",
                     "score": 3,
                     "text": "Metadata is represented in a machine readable format, e.g. in a linked data format such as Resource Description Framework (RDF)."                                                                                
                 }
             ],
-            "aspect": "I",
+            "aspect": "i",
             "guidance": "",
-            "id": "I:q2",
+            "id": "i:q2",
             "principle": "",
             "text": "How is the metadata linked to other data and metadata (to enhance context and clearly indicate relationships)?"                                                                                                          
         },
         {
             "answers": [
                 {
-                    "id": "R:q0:a0",
+                    "id": "r:q0:a0",
                     "score": 0,
                     "text": "No license"
                 },
                 {
-                    "id": "R:q0:a1",
+                    "id": "r:q0:a1",
                     "score": 2,
                     "text": "Non-standard text-based license"
                 },
                 {
-                    "id": "R:q0:a2",
+                    "id": "r:q0:a2",
                     "score": 3,
                     "text": "Non-standard machine-readable license (clearly indicating under what conditions the data may be reused)"                                                                                                         
                 },
                 {
-                    "id": "R:q0:a3",
+                    "id": "r:q0:a3",
                     "score": 3,
                     "text": "Standard text based license"
                 },
                 {
-                    "id": "R:q0:a4",
+                    "id": "r:q0:a4",
                     "score": 4,
                     "text": "Standard machine-readable license (e.g. Creative Commons)"
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "",
-            "id": "R:q0",
+            "id": "r:q0",
             "principle": "",
             "text": "Which of the following best describes the license/usage rights attached to the data?"
         },
         {
             "answers": [
                 {
-                    "id": "R:q1:a0",
+                    "id": "r:q1:a0",
                     "score": 0,
                     "text": "No provenance information is recorded"
                 },
                 {
-                    "id": "R:q1:a1",
+                    "id": "r:q1:a1",
                     "score": 1,
                     "text": "Partially recorded"
                 },
                 {
-                    "id": "R:q1:a2",
+                    "id": "r:q1:a2",
                     "score": 2,
                     "text": "Fully recorded in a text format"
                 },
                 {
-                    "id": "R:q1:a3",
+                    "id": "r:q1:a3",
                     "score": 3,
                     "text": "Fully recorded in a machine readable format"
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "",
-            "id": "R:q1",
+            "id": "r:q1",
             "principle": "",
             "text": "How much provenance information has been captured to facilitate data reuse?"
         }
diff --git a/pages/data/v0.1/questions.test.ts b/pages/data/v0.1/questions.test.ts
index a61cae8..5393e62 100644
--- a/pages/data/v0.1/questions.test.ts
+++ b/pages/data/v0.1/questions.test.ts
@@ -37,20 +37,20 @@ describe('the data questions data', () => {
         expect(re.test(stringified)).toBe(true);
     });
 
-    test('there should be 4 questions with aspect F', () => {
-        expect(questions.filter(q => q.aspect === 'F').length).toBe(4);
+    test('there should be 4 questions with aspect \'f\'', () => {
+        expect(questions.filter(q => q.aspect === 'f').length).toBe(4);
     });
 
-    test('there should be 3 questions with aspect A', () => {
-        expect(questions.filter(q => q.aspect === 'A').length).toBe(3);
+    test('there should be 3 questions with aspect \'a\'', () => {
+        expect(questions.filter(q => q.aspect === 'a').length).toBe(3);
     });
 
-    test('there should be 3 questions with aspect I', () => {
-        expect(questions.filter(q => q.aspect === 'I').length).toBe(3);
+    test('there should be 3 questions with aspect \'i\'', () => {
+        expect(questions.filter(q => q.aspect === 'i').length).toBe(3);
     });
 
-    test('there should be 2 questions with aspect R', () => {
-        expect(questions.filter(q => q.aspect === 'R').length).toBe(2);
+    test('there should be 2 questions with aspect \'r\'', () => {
+        expect(questions.filter(q => q.aspect === 'r').length).toBe(2);
     });
 
     test('there should be 12 questions in total', () => {
diff --git a/pages/data/v0.1/schema.json b/pages/data/v0.1/schema.json
index 06db8ce..519ac75 100644
--- a/pages/data/v0.1/schema.json
+++ b/pages/data/v0.1/schema.json
@@ -34,10 +34,10 @@
                     },
                     "aspect": {
                         "enum": [
-                            "F",
-                            "A",
-                            "I",
-                            "R"
+                            "f",
+                            "a",
+                            "i",
+                            "r"
                         ],
                         "type": "string"
                     },
diff --git a/pages/data/v0.1/store.ts b/pages/data/v0.1/store.ts
index 1dd1ad1..9b7e6db 100644
--- a/pages/data/v0.1/store.ts
+++ b/pages/data/v0.1/store.ts
@@ -1,21 +1,9 @@
-import { computed, ref } from 'vue';
+import { computed } from 'vue';
+import { ref } from 'vue';
+import { Aspect } from './types';
+import { QuestionType } from './types';
 
-type Aspect = 'F' | 'A' | 'I' | 'R';
-
-export type AnswerType = {
-    id: string,
-    score: number,
-    text: string
-}
-
-export type QuestionType = {
-    answers: AnswerType[],
-    aspect: Aspect,
-    guidance: string,
-    id: string,
-    principle: string,
-    text: string
-}
+export const aspects = ['f', 'a', 'i', 'r'] as Aspect[];
 
 const state = ref({
     compliance: [] as number[],
@@ -29,7 +17,8 @@ export const setCompliance = (newCompliance: number[]) => {
 };
 export const setQuestions = (questionsNoIndex: QuestionType[]) => {
     // add index
-    state.value.questions = (questionsNoIndex as QuestionType[]).map((q, i) => ({ ...q, index: i }));
+    state.value.questions = (questionsNoIndex as QuestionType[])
+        .map((q, i) => ({ ...q, index: i }));
     state.value.compliance = new Array(questionsNoIndex.length).fill(0);
 };
 
@@ -38,10 +27,10 @@ export const nQuestions = computed(() => {
         state.value.questions.filter(question => question.aspect === aspect).length
     );
     return {
-        f: deriveNumberOfQuestions('F'),
-        a: deriveNumberOfQuestions('A'),
-        i: deriveNumberOfQuestions('I'),
-        r: deriveNumberOfQuestions('R'),
+        f: deriveNumberOfQuestions('f'),
+        a: deriveNumberOfQuestions('a'),
+        i: deriveNumberOfQuestions('i'),
+        r: deriveNumberOfQuestions('r'),
         total: state.value.questions.length
     };
 });
@@ -56,10 +45,10 @@ export const nPointsMax = computed(() => {
             .reduce((previousValue, currentValue) => previousValue + currentValue, 0);
     };
     return {
-        f: derivePointsMax('F'),
-        a: derivePointsMax('A'),
-        i: derivePointsMax('I'),
-        r: derivePointsMax('R'),
+        f: derivePointsMax('f'),
+        a: derivePointsMax('a'),
+        i: derivePointsMax('i'),
+        r: derivePointsMax('r'),
         total: derivePointsMax('*')
     };
 });
@@ -72,16 +61,29 @@ export const slices = computed(() => {
         r: [number, number]
     }
     return {
-        f: [0, nQuestions.value.f],
-        a: [nQuestions.value.f, nQuestions.value.f + nQuestions.value.a],
-        i: [nQuestions.value.f + nQuestions.value.a, nQuestions.value.f + nQuestions.value.a + nQuestions.value.i],
-        r: [nQuestions.value.f + nQuestions.value.a + nQuestions.value.i, nQuestions.value.total]
+        f: [
+            0,
+            nQuestions.value.f
+        ],
+        a: [
+            nQuestions.value.f,
+            nQuestions.value.f + nQuestions.value.a
+        ],
+        i: [
+            nQuestions.value.f + nQuestions.value.a,
+            nQuestions.value.f + nQuestions.value.a + nQuestions.value.i
+        ],
+        r: [
+            nQuestions.value.f + nQuestions.value.a + nQuestions.value.i,
+            nQuestions.value.total
+        ]
     } as Slices;
 });
 
 export const progress = computed(() => {
     const scoreArrays = state.value.questions.map(q => q.answers.map(a => a.score));
-    const scores = state.value.compliance.map((iAnswer, iQuestion) => scoreArrays[iQuestion][iAnswer]);
+    const scores = state.value.compliance
+        .map((iAnswer, iQuestion) => scoreArrays[iQuestion][iAnswer]);
     const summation = (previousValue: number, currentValue: number) => previousValue + currentValue;
     if (nQuestions.value.total === 0) {
         return {
diff --git a/pages/data/v0.1/types.ts b/pages/data/v0.1/types.ts
new file mode 100644
index 0000000..fb55fa8
--- /dev/null
+++ b/pages/data/v0.1/types.ts
@@ -0,0 +1,16 @@
+export type Aspect = 'f' | 'a' | 'i' | 'r';
+
+export type AnswerType = {
+    id: string,
+    score: number,
+    text: string
+}
+
+export type QuestionType = {
+    answers: AnswerType[],
+    aspect: Aspect,
+    guidance: string,
+    id: string,
+    principle: string,
+    text: string
+}
diff --git a/pages/index/ChecklistFooter.vue b/pages/index/ChecklistFooter.vue
index 7299fe9..4cb4e1a 100644
--- a/pages/index/ChecklistFooter.vue
+++ b/pages/index/ChecklistFooter.vue
@@ -5,7 +5,8 @@
             <img class="logo" src="/ardc-logo.svg" alt="ardc logo" />
         </div>
         <p>
-            This checklist is a collaborative effort by Netherlands eScience Center and Australian Research Data Commons.
+            This checklist is a collaborative effort by
+            Netherlands eScience Center and Australian Research Data Commons.
         </p>
     </footer>
 </template>
diff --git a/pages/index/index.page.vue b/pages/index/index.page.vue
index 99f21a8..054db9b 100644
--- a/pages/index/index.page.vue
+++ b/pages/index/index.page.vue
@@ -2,7 +2,9 @@
 <template>
     <h1>FAIR checklists</h1>
     <p>
-        Choose the checklist for <ChecklistLink v-bind:href="linkToDataChecklist">data</ChecklistLink> or for <ChecklistLink v-bind:href="linkToSoftwareChecklist">software</ChecklistLink>.
+        Choose the checklist for
+        <ChecklistLink v-bind:href="linkToDataChecklist">data</ChecklistLink>
+        or for <ChecklistLink v-bind:href="linkToSoftwareChecklist">software</ChecklistLink>.
     </p>
     <ChecklistFooter />
 </template>
diff --git a/pages/software/v0.1/BannerParams.vue b/pages/software/v0.1/BannerParams.vue
index 7355b0e..bc97b57 100644
--- a/pages/software/v0.1/BannerParams.vue
+++ b/pages/software/v0.1/BannerParams.vue
@@ -7,6 +7,7 @@
 <script setup lang="ts">
 import { onMounted } from 'vue';
 import { ref } from 'vue';
+import { aspects } from './store';
 import { nAnswers } from './store';
 import { nQuestions } from './store';
 import { setCompliance } from './store';
@@ -68,8 +69,7 @@ onMounted(() => {
                 err: true
             };
         }
-        const aspects: Aspect[] = ['f', 'a', 'i', 'r'];
-        const errors = aspects.map(aspect => checkAspect(aspect)).filter(error => error.err === true);
+        const errors = aspects.map(a => checkAspect(a)).filter(error => error.err === true);
         return {
             msg: errors.map(e => e.msg).join('; '),
             err: errors.length > 0
diff --git a/pages/software/v0.1/BannerVersions.vue b/pages/software/v0.1/BannerVersions.vue
index e6ebde8..a3fc825 100644
--- a/pages/software/v0.1/BannerVersions.vue
+++ b/pages/software/v0.1/BannerVersions.vue
@@ -1,6 +1,8 @@
 <template>
     <div class="banner" v-if="showBanner">
-        A newer version of this checklist is available at <ChecklistLink v-bind:href="link">{{link}}</ChecklistLink>, consider upgrading.
+        A newer version of this checklist is available at
+        <ChecklistLink v-bind:href="link">{{link}}</ChecklistLink>
+        , consider upgrading.
     </div>
 </template>
 
diff --git a/pages/software/v0.1/ChecklistHeader.vue b/pages/software/v0.1/ChecklistHeader.vue
index cb9cb54..1924997 100644
--- a/pages/software/v0.1/ChecklistHeader.vue
+++ b/pages/software/v0.1/ChecklistHeader.vue
@@ -17,13 +17,22 @@
                     <g
                     id="outline"
                     transform="matrix(1.032058,0,0,1.032058,-2.0517123,-5.997519)">
-                    <path d="m 64,13.845703 -57.4746094,41.068359 4.6894534,6.5625 7.96289,-5.689453 V 121.80078 H 49.626953 V 91.585938 H 65.746094 V 121.80078 H 108.82227 V 55.787109 l 7.96289,5.689453 4.68945,-6.5625 C 114.12178,49.660112 106.76885,44.406295 99.416016,39.152344 V 17.582031 H 83.607422 V 27.855469 C 77.071721,23.185398 70.535701,18.515774 64,13.845703 Z m 0,15.738281 34.822266,24.882813 V 111.80078 H 75.746094 V 81.585938 H 39.626953 V 111.80078 H 29.177734 V 54.466797 Z" />
+                    <path d="m 64,13.845703 -57.4746094,41.068359 4.6894534,6.5625
+                            7.96289,-5.689453 V 121.80078 H 49.626953 V 91.585938
+                            H 65.746094 V 121.80078 H 108.82227 V 55.787109 l
+                            7.96289,5.689453 4.68945,-6.5625 C 114.12178,49.660112
+                            106.76885,44.406295 99.416016,39.152344 V 17.582031 H
+                            83.607422 V 27.855469 C 77.071721,23.185398 70.535701,18.515774
+                            64,13.845703 Z m 0,15.738281 34.822266,24.882813 V 111.80078
+                            H 75.746094 V 81.585938 H 39.626953 V 111.80078 H 29.177734
+                            V 54.466797 Z" />
                     <g>
                         <path d="m 89.706841,22.049501 h 5.808742 v 12.368457 h -5.808742 z" />
                     </g>
                     </g>
-                    <path
-                    d="M 63.999995,24.525796 99.938597,50.206302 V 109.3783 H 76.122651 V 78.194827 H 38.845604 V 109.3783 H 28.061403 V 50.206302 Z"
+                    <path d="M 63.999995,24.525796 99.938597,50.206302 V 109.3783 H
+                        76.122651 V 78.194827 H 38.845604 V 109.3783 H 28.061403 V
+                        50.206302 Z"
                     id="inside" />
                 </g>
                 </svg>
diff --git a/pages/software/v0.1/index.page.vue b/pages/software/v0.1/index.page.vue
index d00225e..a9b3023 100644
--- a/pages/software/v0.1/index.page.vue
+++ b/pages/software/v0.1/index.page.vue
@@ -7,10 +7,16 @@
             <BannerVersions />
             <BannerParams />
             <template v-if="nQuestions.total > 0">
-                <p>Answer the {{ nQuestions.total }} questions below to assess your software's FAIRness, or switch to the checklist for <ChecklistLink v-bind:href="linkToDataChecklist">data</ChecklistLink> instead.</p>
-                <div v-for="aspect in ['F', 'A', 'I', 'R']" v-bind:key="aspect">
+                <p>
+                    Answer the {{ nQuestions.total }} questions below to assess
+                    your software's FAIRness, or switch to the checklist for
+                    <ChecklistLink v-bind:href="linkToDataChecklist">data</ChecklistLink>
+                    instead.
+                </p>
+                <div v-for="aspect in aspects" v-bind:key="aspect">
                     <h2>{{ getAspectFullname(aspect) }}</h2>
-                    <ChecklistQuestion v-for="question in questions.filter(q => q.aspect === aspect)"
+                    <ChecklistQuestion
+                        v-for="question in questions.filter(q => q.aspect === aspect)"
                         v-bind:key="question.id"
                         v-bind:question="question"
                     />
@@ -34,11 +40,13 @@
 import { onMounted } from 'vue';
 import { ref } from 'vue';
 import { latest } from '~/renderer/versions';
+import { aspects } from './store';
 import { nQuestions } from './store';
 import { progress } from './store';
 import { questions } from './store';
 import { setQuestions } from './store';
-import { type QuestionType } from './store';
+import { type QuestionType } from './types';
+import { type Aspect } from './types';
 import BadgeSnippets from './BadgeSnippets.vue';
 import BannerParams from './BannerParams.vue';
 import BannerVersions from './BannerVersions.vue';
@@ -55,11 +63,11 @@ setQuestions(data as QuestionType[]);
 
 const disableButton = ref(false);
 
-const getAspectFullname = (aspect: 'F' | 'A' | 'I' | 'R') => ({
-    F: 'Findable',
-    A: 'Accessible',
-    I: 'Interoperable',
-    R: 'Reusable'
+const getAspectFullname = (aspect: Aspect) => ({
+    f: 'Findable',
+    a: 'Accessible',
+    i: 'Interoperable',
+    r: 'Reusable'
 }[aspect]);
 const scrollToBadgesSection = () => {
     document.getElementById('badges-section')?.scrollIntoView({ behavior: 'smooth' });
diff --git a/pages/software/v0.1/questions.json b/pages/software/v0.1/questions.json
index eb40e92..3074004 100644
--- a/pages/software/v0.1/questions.json
+++ b/pages/software/v0.1/questions.json
@@ -3,502 +3,502 @@
         {
             "answers": [
                 {
-                    "id": "F:q0:a0",
+                    "id": "f:q0:a0",
                     "score": 0,
                     "text": "No identifier"
                 },
                 {
-                    "id": "F:q0:a1",
+                    "id": "f:q0:a1",
                     "score": 1,
                     "text": "Local identifier or reasonably unique name"
                 },
                 {
-                    "id": "F:q0:a2",
+                    "id": "f:q0:a2",
                     "score": 2,
                     "text": "Web address (URL)"
                 },
                 {
-                    "id": "F:q0:a3",
+                    "id": "f:q0:a3",
                     "score": 3,
                     "text": "Globally unique and persistent identifier (e.g. DOI, PURL, or Handle)"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "A uniquely named piece of software is not the same as an identifier as it might be linked to a registry or programming language. A Uniform Resource Locator (URL) is a kind of unique identifier, but might not be persistent.",                                                                                 
-            "id": "F:q0",
+            "id": "f:q0",
             "principle": "F1. Software is assigned a globally unique and persistent identifier",
             "text": "Does the software have any identifier assigned?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q1:a0",
+                    "id": "f:q1:a0",
                     "score": 0,
                     "text": "No identifier"
                 },
                 {
-                    "id": "F:q1:a1",
+                    "id": "f:q1:a1",
                     "score": 1,
                     "text": "There is only one identifier for the entire bundle/package"
                 },
                 {
-                    "id": "F:q1:a2",
+                    "id": "f:q1:a2",
                     "score": 2,
                     "text": "Some components have distinct identifiers"
                 },
                 {
-                    "id": "F:q1:a3",
+                    "id": "f:q1:a3",
                     "score": 3,
                     "text": "Each component has a PID with reference to a top level PID"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "A persistent identifier (PID) like a DOI, PURL or Handle has the following characteristics: globally unique, citable and persistent. The granularity is decided for each software and its maturity.",                                                                                                            
-            "id": "F:q1",
+            "id": "f:q1",
             "principle": "F1.1. Different components of the software are assigned distinct identifiers representing different levels of granularity",
             "text": "Are different components of the software assigned distinct identifiers representing different levels of granularity?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q2:a0",
+                    "id": "f:q2:a0",
                     "score": 0,
                     "text": "No identifier"
                 },
                 {
-                    "id": "F:q2:a1",
+                    "id": "f:q2:a1",
                     "score": 1,
                     "text": "Each major version (version X) is assigned an identifier"
                 },
                 {
-                    "id": "F:q2:a2",
+                    "id": "f:q2:a2",
                     "score": 2,
                     "text": "available versions distinctly identified"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "Version is one of the granularity levels identified as most relevant. Depending on the maturity of the software development, not only major versions but minor and point versions are also encouraged. For example: - each minor version (version X.Y) is assigned an identifier - Each point version (version X.Y.Z) is assigned an identifier",                                                                                                                                   
-            "id": "F:q2",
+            "id": "f:q2",
             "principle": "F1.2. Different versions of the same software are assigned distinct identifiers.",
             "text": "Are different versions of the same software identified?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q3:a0",
+                    "id": "f:q3:a0",
                     "score": 0,
                     "text": "The software is not described with any metadata"
                 },
                 {
-                    "id": "F:q3:a1",
+                    "id": "f:q3:a1",
                     "score": 1,
                     "text": "The software has a title and a brief description"
                 },
                 {
-                    "id": "F:q3:a2",
+                    "id": "f:q3:a2",
                     "score": 2,
                     "text": "Title, description, and multiple fields are provided, albeit informally (not using a standard format)"
                 },
                 {
-                    "id": "F:q3:a3",
+                    "id": "f:q3:a3",
                     "score": 3,
                     "text": "Described comprehensively using a formal machine-readable metadata schema "
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "See also Interoperable and Reusable for specific questions about relationships between objects, and about specific kinds of metadata. Rich metadata constitutes a plurality of attributes (for R1): (e.g. name, version, contributors roles, programming language, description of the purpose, science domain, key words, licence, PID, related identifiers) Examples of formal machine-readable metadata schemas are (e.g. Citation.CFF, .zenodo.json, codemeta.jsonld)",          
-            "id": "F:q3",
+            "id": "f:q3",
             "principle": "F2. Software is described with rich metadata.",
             "text": "Is the software described with rich metadata?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q4:a0",
+                    "id": "f:q4:a0",
                     "score": 0,
                     "text": "No metadata"
                 },
                 {
-                    "id": "F:q4:a1",
+                    "id": "f:q4:a1",
                     "score": 1,
                     "text": "Metadata does not include an identifier for the software"
                 },
                 {
-                    "id": "F:q4:a2",
+                    "id": "f:q4:a2",
                     "score": 2,
                     "text": "The identifier is captured in the metadata that describes the software"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "The identifier is recommended to be globally unique and persistent. Those features enable citability. F3 calls for that identifier to be included within the metadata record that the identifier points to",                                                                                                     
-            "id": "F:q4",
+            "id": "f:q4",
             "principle": "F3. Metadata clearly and explicitly include the identifier of the software they describe.",
             "text": "Is the identifier included in the metadata that describes the software?"
         },
         {
             "answers": [
                 {
-                    "id": "F:q5:a0",
+                    "id": "f:q5:a0",
                     "score": 0,
                     "text": "No metadata"
                 },
                 {
-                    "id": "F:q5:a1",
+                    "id": "f:q5:a1",
                     "score": 1,
                     "text": "Metadata is not structured"
                 },
                 {
-                    "id": "F:q5:a2",
+                    "id": "f:q5:a2",
                     "score": 2,
                     "text": "Metadata might be searchable and indexable but not FAIR"
                 },
                 {
-                    "id": "F:q5:a3",
+                    "id": "f:q5:a3",
                     "score": 3,
                     "text": "Metadata is structured in a FAIR way"
                 }
             ],
-            "aspect": "F",
+            "aspect": "f",
             "guidance": "Many of the questions here relate to making the metadata associated with software FAIR. Principles F2, F3, A2, R1, and R2 all relate to making the metadata associated with software FAIR. Here the focus is on that metadata being captured in a way that enables searching and indexing of that metadata. For instance, a codemeta file may hold the relevant metadata, but if it is not exposed (or integrated) in a way that enables indexing, then it will not fulfil this criterion. Here this consideration is not just that the metadata exists, but also that it is available in a system that enables it to be FAIR.",                       
-            "id": "F:q5",
+            "id": "f:q5",
             "principle": "F4. Metadata are FAIR, and are searchable and indexable.",
             "text": "Are metadata FAIR, searchable and indexable?"
         },
         {
             "answers": [
                 {
-                    "id": "A:q0:a0",
+                    "id": "a:q0:a0",
                     "score": 0,
                     "text": "No access to software, or there are unspecified access conditions, or software is not retrievable by its identifier"
                 },
                 {
-                    "id": "A:q0:a1",
+                    "id": "a:q0:a1",
                     "score": 1,
                     "text": "Software is retrieved via its identifier with defined access conditions, but access is closed or mediated by individual arrangement"
                 },
                 {
-                    "id": "A:q0:a2",
+                    "id": "a:q0:a2",
                     "score": 2,
                     "text": "Stated minimal restrictions for software to be downloaded from an online location (e.g personal or group website or FTP server)"
                 },
                 {
-                    "id": "A:q0:a3",
+                    "id": "a:q0:a3",
                     "score": 3,
                     "text": "Software can be retrieved from a publicly-accessible code development repository, package or library manager or software registry or archive"                                                                                                                                                                
                 }
             ],
-            "aspect": "A",
+            "aspect": "a",
             "guidance": "Software is retrievable from: - a publicly-accessible code development repository (e.g. GitHub, GitLab, BitBucket, etc), - a package or library manager (e.g apt, CRAN, PyPI, etc), - a research software registry  (e.g. see this list), or - an archive.",                                                     
-            "id": "A:q0",
+            "id": "a:q0",
             "principle": "A1. Software is retrievable by its identifier using a standardised communications protocol.",
             "text": "Can the software be retrieved via its identifier using standardised protocols?"
         },
         {
             "answers": [
                 {
-                    "id": "A:q1:a0",
+                    "id": "a:q1:a0",
                     "score": 0,
                     "text": "No metadata record exists"
                 },
                 {
-                    "id": "A:q1:a1",
+                    "id": "a:q1:a1",
                     "score": 1,
                     "text": "Metadata exists, but is not accessible via an identifier"
                 },
                 {
-                    "id": "A:q1:a2",
+                    "id": "a:q1:a2",
                     "score": 2,
                     "text": "Metadata is retrievable via an identifier"
                 },
                 {
-                    "id": "A:q1:a3",
+                    "id": "a:q1:a3",
                     "score": 3,
                     "text": "And is machine readable"
                 }
             ],
-            "aspect": "A",
+            "aspect": "a",
             "guidance": "Some formal machine-readable metadata schema exist specifically for software (e.g. Citation.CFF, .zenodo.json, codemeta.jsonld). Mechanisms for retrieving metadata include DataCite DOI metadata, encoding of metadata using schema.org on the page resolved to by the identifier, and retrieval via a package manager",                                                                                                                                                           
-            "id": "A:q1",
+            "id": "a:q1",
             "principle": "A1. Software is retrievable by its identifier using a standardised communications protocol.",
             "text": "Can metadata be retrieved via is identifier using standardised protocols?"
         },
         {
             "answers": [
                 {
-                    "id": "A:q2:a0",
+                    "id": "a:q2:a0",
                     "score": 0,
                     "text": "No (e.g. a specialized client using a closed protocol might be required to download the software)"
                 },
                 {
-                    "id": "A:q2:a1",
+                    "id": "a:q2:a1",
                     "score": 1,
                     "text": "Protocol is not open or free and allows for authentication and authorisation"
                 },
                 {
-                    "id": "A:q2:a2",
+                    "id": "a:q2:a2",
                     "score": 2,
                     "text": "Protocol is open and free but does not allow for authentication and authorisation"
                 },
                 {
-                    "id": "A:q2:a3",
+                    "id": "a:q2:a3",
                     "score": 3,
                     "text": "Yes"
                 }
             ],
-            "aspect": "A",
+            "aspect": "a",
             "guidance": "This question refers to the combinations of these two principles [define protocol] [describe authentication and authorisation]",
-            "id": "A:q2",
+            "id": "a:q2",
             "principle": "A1.1. The protocol is open, free, and universally implementable. A1.2. The protocol allows for an authentication and authorisation procedure, where necessary.",                                                                                                                                                
             "text": "Is the protocol open, free and universally implementable? and does it allow for authentication and autorisation procedures?"
         },
         {
             "answers": [
                 {
-                    "id": "A:q3:a0",
+                    "id": "a:q3:a0",
                     "score": 0,
                     "text": "Not applicable, no metadata record exists"
                 },
                 {
-                    "id": "A:q3:a1",
+                    "id": "a:q3:a1",
                     "score": 1,
                     "text": "No, metadata is lost if software is no longer accessible"
                 },
                 {
-                    "id": "A:q3:a2",
+                    "id": "a:q3:a2",
                     "score": 2,
                     "text": "Unsure, whether the institution/registry provides this feature"
                 },
                 {
-                    "id": "A:q3:a3",
+                    "id": "a:q3:a3",
                     "score": 3,
                     "text": "Yes"
                 }
             ],
-            "aspect": "A",
+            "aspect": "a",
             "guidance": "Mostly a feature of the metadata registry",
-            "id": "A:q3",
+            "id": "a:q3",
             "principle": "A2. Metadata are accessible, even when the software is no longer available.",
             "text": "Are metadata accessible, even when the software is no longer available?"
         },
         {
             "answers": [
                 {
-                    "id": "I:q0:a0",
+                    "id": "i:q0:a0",
                     "score": 0,
                     "text": "No Domain-relevant data input/output standard is implemented"
                 },
                 {
-                    "id": "I:q0:a1",
+                    "id": "i:q0:a1",
                     "score": 1,
                     "text": "Standard data input/output"
                 },
                 {
-                    "id": "I:q0:a2",
+                    "id": "i:q0:a2",
                     "score": 2,
                     "text": "Input/output meets domain-relevant standards"
                 }
             ],
-            "aspect": "I",
+            "aspect": "i",
             "guidance": "A domain-relevant standard is an agreed standard that addresses the needs of a given community (or communities). For interoperation between software it is necessary that more than one software tool supports common standards for interchange. Ideally, related research software are capable of exchanging data or metadata because they all implement common standards. The way in which the data is transmitted might be via reading and writing files, or by passing arguments to an API and receiving responses. Barriers to meeting this guiding principle include a lack of relevant standards, a lack of community consensus on relevant standards, a lack of implementations of agreed upon standards. Work outside the software itself may need to be done before this guiding principle can be addressed.",  
-            "id": "I:q0",
+            "id": "i:q0",
             "principle": "I1. Software reads, writes and exchanges data in a way that meets domain-relevant community standards.",
             "text": "Are the data written/read or exchanged by the software machine readable and in (an) open (file) format(s)?"
         },
         {
             "answers": [
                 {
-                    "id": "I:q1:a0",
+                    "id": "i:q1:a0",
                     "score": 0,
                     "text": "There are no links to other metadata or data"
                 },
                 {
-                    "id": "I:q1:a1",
+                    "id": "i:q1:a1",
                     "score": 1,
                     "text": "The metadata record includes URI links to related metadata, data and definitions"
                 },
                 {
-                    "id": "I:q1:a2",
+                    "id": "i:q1:a2",
                     "score": 2,
                     "text": "Qualified links to other resources are recorded in a machine readable format"
                 }
             ],
-            "aspect": "I",
+            "aspect": "i",
             "guidance": "I2. Software includes qualified references to other objects.",
-            "id": "I:q1",
+            "id": "i:q1",
             "principle": "Software may utilise external data, metadata and other similar objects. Ideally, these should also be FAIR when possible. A qualified reference is a pointer to the other object, with a clear authority for resolving/confirming that identity given in the form of the reference. Ideally this is in a form that includes a resolver within the reference (e.g., in the form of a URL).",                                                                                        
             "text": "How is the relationship to data and metadata described in the metadata and software? (see R:q4 for relationship to other software)"
         },
         {
             "answers": [
                 {
-                    "id": "R:q0:a0",
+                    "id": "r:q0:a0",
                     "score": 0,
                     "text": "Non-accessible form"
                 },
                 {
-                    "id": "R:q0:a1",
+                    "id": "r:q0:a1",
                     "score": 1,
                     "text": "Undocumented binary form"
                 },
                 {
-                    "id": "R:q0:a2",
+                    "id": "r:q0:a2",
                     "score": 2,
                     "text": "Documented binary form"
                 },
                 {
-                    "id": "R:q0:a3",
+                    "id": "r:q0:a3",
                     "score": 3,
                     "text": "Source code available in a repository and documented"
                 },
                 {
-                    "id": "R:q0:a4",
+                    "id": "r:q0:a4",
                     "score": 4,
                     "text": "Source code available via a package manager or similar"
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "Specifically it considers reusability in the sense of software being understood, built upon or incorporated into other software, but not necessarily executed (again). Sensitivities may restrict access to the software. The form of the software or the way in which it is made available restricts the way in which it can be understood. A service may obscure all internal workings of the software if no alternate form is made available. A compiled binary form is not as easily pulled apart or understood as a source code representation. Binaries in some cases can be built upon or incorporated into other software, but this is especially the case when it the programming interface to that software is fully documented. Source code is the most straightforwardly interrogable form of software, but in some circumstances making this form available may not be possible, practical or desirable.",                                                                      
-            "id": "R:q0",
+            "id": "r:q0",
             "principle": "Reuseable: Software is both usable (it can be executed) and reusable (it can be understood, modified, built upon, or incorporated into other software).",                                                                                                                                                       
             "text": "Can software be understood, modified, built upon, or incorporated into other software? Is software made available in a form that makes this easy to do? Links to A:q0"                                                                                                                                               
         },
         {
             "answers": [
                 {
-                    "id": "R:q1:a0",
+                    "id": "r:q1:a0",
                     "score": 0,
                     "text": "No, access to the binary or source code is not available"
                 },
                 {
-                    "id": "R:q1:a1",
+                    "id": "r:q1:a1",
                     "score": 1,
                     "text": "Yes, a binary is available and it has an executable environment clearly described in order to execute the software"
                 },
                 {
-                    "id": "R:q1:a2",
+                    "id": "r:q1:a2",
                     "score": 2,
                     "text": "Yes, the software is packaged with access to dependencies."
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "Specifically it considers reusability in the sense of software be able to be executed, not in the sense of it being understood, built upon or incorporated into other software. Factors affecting the executability of the software include documentation of configuration, dependencies and execution environment (software and hardware). These can be captured in a human readable format (such as text), but are ideally captured in a machine readable format as well. In some cases, it may be possible or desirable to make the software available in a packaged form to facilitate reuse. For example, an emulation environment where the software is run executable. Also a container where the software and its dependencies are all encapsulated. Or it could be that the software is made available via a package management system.",                                                                                                                                           
-            "id": "R:q1",
+            "id": "r:q1",
             "principle": "Reuseable: Software is both usable (it can be executed) and reusable (it can be understood, modified, built upon, or incorporated into other software).",                                                                                                                                                       
             "text": "Is the software (re)executable? Can it easily be run (again)?"
         },
         {
             "answers": [
                 {
-                    "id": "R:q2:a0",
+                    "id": "r:q2:a0",
                     "score": 0,
                     "text": "No license is attached"
                 },
                 {
-                    "id": "R:q2:a1",
+                    "id": "r:q2:a1",
                     "score": 1,
                     "text": "Non-standard license is attached"
                 },
                 {
-                    "id": "R:q2:a2",
+                    "id": "r:q2:a2",
                     "score": 2,
                     "text": "Machine-readable non-standard license"
                 },
                 {
-                    "id": "R:q2:a3",
+                    "id": "r:q2:a3",
                     "score": 3,
                     "text": "Standard license"
                 },
                 {
-                    "id": "R:q2:a4",
+                    "id": "r:q2:a4",
                     "score": 4,
                     "text": "Machine readable standard license"
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "Standard licenses are those that are widely recognised. Licences are often referred to by name, but machine readable licenses can be specified by reference to a standard vocabulary such as SPDX, or are encoded in a machine readable format such as RDF/XML in the metadata record for the software.  Ideally the license deed is available in the package or linked to by a standard URL. Note that Creative Commons licenses are not recommended for software.",               
-            "id": "R:q2",
+            "id": "r:q2",
             "principle": "R1.1. Software is given a clear and accessible licence.",
             "text": "Which of the following best describes the license (usage rights) attached to the software?"
         },
         {
             "answers": [
                 {
-                    "id": "R:q3:a0",
+                    "id": "r:q3:a0",
                     "score": 0,
                     "text": "No provenance detail given"
                 },
                 {
-                    "id": "R:q3:a1",
+                    "id": "r:q3:a1",
                     "score": 1,
                     "text": "Partially recorded as human readable text"
                 },
                 {
-                    "id": "R:q3:a2",
+                    "id": "r:q3:a2",
                     "score": 2,
                     "text": "Comprehensively recorded"
                 },
                 {
-                    "id": "R:q3:a3",
+                    "id": "r:q3:a3",
                     "score": 3,
                     "text": "Comprehensively recorded in a machine readable format"
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "Provenance answers the \"who, what, when, where, why and how\" for the development of the software. Providing detailed provenance gives a user the details they need to trust that the software will do what they expect it to do. This extends well beyond whether the software and its development over time has been captured in a version control system. A record of provenance captures information such as the people, their roles in making contributions, the resources committed (for instance grants, people-time, hardware), the time span of a project (or projects) focussed on the work,  the geographic location of the authors or their affiliations with organisations, the project objectives or intent in producing the software and the agreed upon process, systems and/or constraints (including changes in licensing) on the development of the software. All of this detail can help to interpret and understand how and why the software came to be, and to engender trust in reuse. A partial capture of provenance captures only some of this detail. This detail can also be comprehensive but not machine readable. Examples of machine readable provenance standards include PROV, and formats include RDF, JSON, NetCDF, XML, etc.",                                                               
-            "id": "R:q3",
+            "id": "r:q3",
             "principle": "R1.2. Software is associated with detailed provenance.",
             "text": "How much provenance information has been captured to facilitate software reuse? (e.g., project objectives, processes, authors, roles, contributions, use of other components)."                                                                                                                                      
         },
         {
             "answers": [
                 {
-                    "id": "R:q4:a0",
+                    "id": "r:q4:a0",
                     "score": 0,
                     "text": "Dependencies are expressed by name only, or not at all"
                 },
                 {
-                    "id": "R:q4:a1",
+                    "id": "r:q4:a1",
                     "score": 1,
                     "text": "Dependencies named, but no version detail is provided"
                 },
                 {
-                    "id": "R:q4:a2",
+                    "id": "r:q4:a2",
                     "score": 2,
                     "text": "The metadata record includes URI links to related software dependencies"
                 },
                 {
-                    "id": "R:q4:a3",
+                    "id": "r:q4:a3",
                     "score": 3,
                     "text": "Qualified links to other software are recorded in a machine readable format"
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "A qualified reference is a pointer to an external object, with a clear authority for resolving/confirming that identity given in the form of the reference. Ideally this is in a form that includes a resolver within the reference (e.g., in the form of a URI). For software this would mean referring to other software via a resolvable, qualified permanent identifier. In metadata this is only possible when software is able to be referred to in this fashion. Not all software can be referred to in this way. A qualified reference in software is presently technically difficult or impossible in many languages, where conventional practice is to use a (unqualified) reference via a (possibly non-unique) name, possibly in combination with a version number.",                                         
-            "id": "R:q4",
+            "id": "r:q4",
             "principle": "R2. Software includes qualified references to other software.",
             "text": "How is the relationship to software described in the metadata and software? (see I:q1 for relationship to other components such as data and metadata)"                                                                                                                                                               
         },
         {
             "answers": [
                 {
-                    "id": "R:q5:a0",
+                    "id": "r:q5:a0",
                     "score": 0,
                     "text": "No standards looked for, or applied"
                 },
                 {
-                    "id": "R:q5:a1",
+                    "id": "r:q5:a1",
                     "score": 1,
                     "text": "Looked for standards, but unclear or unavailable"
                 },
                 {
-                    "id": "R:q5:a2",
+                    "id": "r:q5:a2",
                     "score": 2,
                     "text": "Uses domain-relevant standards"
                 }
             ],
-            "aspect": "R",
+            "aspect": "r",
             "guidance": "Relevant research domains are determined by the intended user base of the software, not any possible community of use for a piece of software. A piece of software created to address the needs of a community should be aware of any standards put forward by that community or adjacent ones. Similarly, a piece of software (such as analysis code) which is intended to represent work done within a domain-community should also be aware of any standards put forward by that community or adjacent ones. Some examples of domain-relevant community standards are: (e.g. CoC, Credit to authors and collaborations, institutional standards, registry standards, nomenclature described within a community)",                                                                                                      
-            "id": "R:q5",
+            "id": "r:q5",
             "principle": "R3. Software meets domain-relevant community standards.",
             "text": "If they exist, how much have domain-relevant community standards been considered in writing the software? it is linked to I:q0"
         }
diff --git a/pages/software/v0.1/questions.test.ts b/pages/software/v0.1/questions.test.ts
index 06a5dfd..ed07f72 100644
--- a/pages/software/v0.1/questions.test.ts
+++ b/pages/software/v0.1/questions.test.ts
@@ -36,20 +36,20 @@ describe('the software questions data', () => {
         expect(re.test(stringified)).toBe(true);
     });
 
-    test('there should be 6 questions with aspect F', () => {
-        expect(questions.filter(q => q.aspect === 'F').length).toBe(6);
+    test('there should be 6 questions with aspect \'f\'', () => {
+        expect(questions.filter(q => q.aspect === 'f').length).toBe(6);
     });
 
-    test('there should be 4 questions with aspect A', () => {
-        expect(questions.filter(q => q.aspect === 'A').length).toBe(4);
+    test('there should be 4 questions with aspect \'a\'', () => {
+        expect(questions.filter(q => q.aspect === 'a').length).toBe(4);
     });
 
-    test('there should be 2 questions with aspect I', () => {
-        expect(questions.filter(q => q.aspect === 'I').length).toBe(2);
+    test('there should be 2 questions with aspect \'i\'', () => {
+        expect(questions.filter(q => q.aspect === 'i').length).toBe(2);
     });
 
-    test('there should be 6 questions with aspect R', () => {
-        expect(questions.filter(q => q.aspect === 'R').length).toBe(6);
+    test('there should be 6 questions with aspect \'r\'', () => {
+        expect(questions.filter(q => q.aspect === 'r').length).toBe(6);
     });
 
     test('there should be 18 questions in total', () => {
diff --git a/pages/software/v0.1/schema.json b/pages/software/v0.1/schema.json
index 06db8ce..519ac75 100644
--- a/pages/software/v0.1/schema.json
+++ b/pages/software/v0.1/schema.json
@@ -34,10 +34,10 @@
                     },
                     "aspect": {
                         "enum": [
-                            "F",
-                            "A",
-                            "I",
-                            "R"
+                            "f",
+                            "a",
+                            "i",
+                            "r"
                         ],
                         "type": "string"
                     },
diff --git a/pages/software/v0.1/store.ts b/pages/software/v0.1/store.ts
index f2330ab..847c14c 100644
--- a/pages/software/v0.1/store.ts
+++ b/pages/software/v0.1/store.ts
@@ -1,22 +1,9 @@
 import { computed } from 'vue';
 import { ref } from 'vue';
+import { Aspect } from './types';
+import { QuestionType } from './types';
 
-type Aspect = 'F' | 'A' | 'I' | 'R';
-
-export type AnswerType = {
-    id: string,
-    score: number,
-    text: string
-}
-
-export type QuestionType = {
-    answers: AnswerType[],
-    aspect: Aspect,
-    guidance: string,
-    id: string,
-    principle: string,
-    text: string
-}
+export const aspects = ['f', 'a', 'i', 'r'] as Aspect[];
 
 const state = ref({
     compliance: [] as number[],
@@ -30,17 +17,19 @@ export const setCompliance = (newCompliance: number[]) => {
 };
 export const setQuestions = (questionsNoIndex: QuestionType[]) => {
     // add index
-    state.value.questions = (questionsNoIndex as QuestionType[]).map((q, i) => ({ ...q, index: i }));
+    state.value.questions = (questionsNoIndex as QuestionType[])
+        .map((q, i) => ({ ...q, index: i }));
     state.value.compliance = new Array(questionsNoIndex.length).fill(0);
 };
 
 export const nQuestions = computed(() => {
-    const deriveNumberOfQuestions = (aspect: Aspect) => state.value.questions.filter(question => question.aspect === aspect).length;
+    const deriveNumberOfQuestions = (aspect: Aspect) => state.value.questions
+        .filter(question => question.aspect === aspect).length;
     return {
-        f: deriveNumberOfQuestions('F'),
-        a: deriveNumberOfQuestions('A'),
-        i: deriveNumberOfQuestions('I'),
-        r: deriveNumberOfQuestions('R'),
+        f: deriveNumberOfQuestions('f'),
+        a: deriveNumberOfQuestions('a'),
+        i: deriveNumberOfQuestions('i'),
+        r: deriveNumberOfQuestions('r'),
         total: state.value.questions.length
     };
 });
@@ -56,10 +45,10 @@ export const nPointsMax = computed(() => {
             .reduce((previousValue, currentValue) => previousValue + currentValue, 0);
     };
     return {
-        f: derivePointsMax('F'),
-        a: derivePointsMax('A'),
-        i: derivePointsMax('I'),
-        r: derivePointsMax('R'),
+        f: derivePointsMax('f'),
+        a: derivePointsMax('a'),
+        i: derivePointsMax('i'),
+        r: derivePointsMax('r'),
         total: derivePointsMax('*')
     };
 });
@@ -72,10 +61,22 @@ export const slices = computed(() => {
         r: [number, number]
     }
     return {
-        f: [0, nQuestions.value.f],
-        a: [nQuestions.value.f, nQuestions.value.f + nQuestions.value.a],
-        i: [nQuestions.value.f + nQuestions.value.a, nQuestions.value.f + nQuestions.value.a + nQuestions.value.i],
-        r: [nQuestions.value.f + nQuestions.value.a + nQuestions.value.i, nQuestions.value.total]
+        f: [
+            0,
+            nQuestions.value.f
+        ],
+        a: [
+            nQuestions.value.f,
+            nQuestions.value.f + nQuestions.value.a
+        ],
+        i: [
+            nQuestions.value.f + nQuestions.value.a,
+            nQuestions.value.f + nQuestions.value.a + nQuestions.value.i
+        ],
+        r: [
+            nQuestions.value.f + nQuestions.value.a + nQuestions.value.i,
+            nQuestions.value.total
+        ]
     } as Slices;
 });
 
@@ -98,7 +99,8 @@ export const fairQueryParams = computed(() => [
 
 export const progress = computed(() => {
     const scoreArrays = state.value.questions.map(q => q.answers.map(a => a.score));
-    const scores = state.value.compliance.map((iAnswer, iQuestion) => scoreArrays[iQuestion][iAnswer]);
+    const scores = state.value.compliance
+        .map((iAnswer, iQuestion) => scoreArrays[iQuestion][iAnswer]);
     const summation = (previousValue: number, currentValue: number) => previousValue + currentValue;
     if (nQuestions.value.total === 0) {
         return {
diff --git a/pages/software/v0.1/types.ts b/pages/software/v0.1/types.ts
new file mode 100644
index 0000000..ed52a53
--- /dev/null
+++ b/pages/software/v0.1/types.ts
@@ -0,0 +1,16 @@
+export type AnswerType = {
+    id: string,
+    score: number,
+    text: string
+}
+
+export type Aspect = 'f' | 'a' | 'i' | 'r';
+
+export type QuestionType = {
+    answers: AnswerType[],
+    aspect: Aspect,
+    guidance: string,
+    id: string,
+    principle: string,
+    text: string
+}