:recycle: further simplifying lists | adding sidebar back to single

vue-theme/src/pages/list.vue

             return this.$route.params.sortBy
         },
         pType() {
-            if(!typeFromRoute(this.$route)) return
-            return this.sortBy ? `${convertTitleCase(typeFromRoute(this.$route).split('/')[0])}s` : `${convertTitleCase(this.type)}s`
+            if(!this.type) return
+            return `${convertTitleCase(this.type)}s`
         },
         loaded() {
             if (!this.pType) return
         },
     },
     methods: {
-        _getDispatchParams(perPageOverride) {
-            return {
-                sortType: this.sortBy,
-                params: {
-                    limit: perPageOverride ? perPageOverride : this.perPage,
-                    page: this.page
-                }
-            }
-        },
         clearAllPosts() {
             if(!this.type) return console.error(`post type: ${this.type} not found...`)
-            this.$store.commit(`CLEAR_${this.type.toUpperCase()}S`)
+            this.$store.commit(`CLEAR_${this.pType.toUpperCase()}`)
             // this.$store.commit(`${this.type.toUpperCase()}S_LOADED`)
         },
         async loadMorePosts() {
             if(!this.type) throw `post type: ${this.type} not found...`
 
             // Set some default dispatch paramters
-            let dispatchAction = `getMore${this.pType}`
-            let params = this._getDispatchParams()
+            let dispatchAction = 'More'
+            let params = { limit: this.perPage, page: this.page }
             
             // For episodes, or material sort we grab EVERYTHING
             const getAllClause = this.type == 'episode' || this.type == 'artist' && this.sortBy == sortTypes.material
             if(getAllClause) {
-                dispatchAction = `getAll${this.pType}`
-                params = this._getDispatchParams(-1)
-                
-                // Clear sortType if this is an episodes list
-                params.sortType = this.type == 'episode' ? null : params.sortType
+                dispatchAction = 'All'
+                params.limit = -1
             }
 
             let res = []
             // We always grab all pages on hero init so no need to do it here
             if(this.pType && this.keepFetching && this.type != 'page') {
-                res = await this.$store.dispatch(dispatchAction, params)
+                res = await this.$store.dispatch(`get${dispatchAction}${this.pType}`, { sortType: this.sortBy, params })
             }
 
             // Stop trying to load more posts
             }
         },
         clearAndInitPostList(caller) {
-            console.log(`clearAndInitPostList from ${caller}...`)
-            console.log('---')
-
             this.page = 0
             this.keepFetching = true
 
         // This only fires navigating from
         // a list page, to another list page
         // and the post type has changed
-        type(newType, oldType) {
-            if(!postTypes.includes(newType)) return console.warn('type not valid...')
+        type(newType) {
+            if(!postTypes.includes(newType)) return console.warn('Type not valid...')
 
             // Ignore types with presorts so the sortBy watcher can handle them
             const ignore = ['event', 'exhibition', 'artist']
             
             this.clearAndInitPostList('type change')
         },
-        sortBy(newSort, oldSort) {
+        sortBy(newSort) {
             if(Object.values(sortTypes).includes(newSort)) {
                 this.clearAndInitPostList('sort change')
             }
-        },
-        // Only fire if the sort type has changed
-        // and the post type is the same
-        // and both sorts are valid
-        $route(to, from) {
-            console.log('to :', to)
         }
     },
     mounted() {

vue-theme/src/pages/single.vue

 
 export default {
     components: { sidebar, gallery, credits, card, breadcrumb },
-    props: {
-        sidebar: { type: Boolean },
-    },
     mixins: [postTypeGetters, scrollTop, heroUtils],
     data() {
         return {
         }
     },
     computed: {
+        sidebar() {
+            return true
+        },
         type() {
             // Checks for type and fixes Episodes route edge case
-            return typeFromRoute(this.$route)
+            return this.$route.params.type
         },
         /**
          * We get the actual post data using the slug
          */
         singlePost() {
             if (!this[this.type]) return
-            const type = dePluralize(this.type)
 
             // State not a getter!
             const singleOfTypeFromState =
-                this[this.type][`single${convertTitleCase(type)}`]
+                this[this.type][`single${convertTitleCase(this.type)}`]
 
             if (!singleOfTypeFromState) return
 
             Object.keys(byIndex).forEach(galleryIndex => {
                 if (
                     byIndex[galleryIndex].includes(
-                        parseInt(imageInfo.dataset.id),
+                        parseInt(imageInfo.dataset.id)
                     )
                 )
                     matchingIndex = galleryIndex
          */
         checkAndSetHero(post) {
             this._clearHero(this.$store)
-            if (!post) return console.warn(`no post found`)
+            if (!post) throw `No post found. Cannot set hero.`
             this.$store.commit('SET_HERO', this._setHeroInfo(post))
         },
 
             /**
              * At the point we MUST have singlePostData
              */
-            this.checkAndSetHero(singlePostData)
-            await this.$store.dispatch(
-                `getSingle${convertTitleCase(this.type)}`,
-                singlePostData.id,
-            )
+            try {
+                this.checkAndSetHero(singlePostData)
+                await this.$store.dispatch(
+                    `getSingle${convertTitleCase(this.type)}`,
+                    singlePostData.id,
+                )
+            } catch (err) {
+                console.error(err)
+            }
             this.loading = false
         },
     },
         $route(to, from) {
             // Only load post data when navigating TO a single page
             const path = to.fullPath.split('/').filter(p => p)
-            const hasSort = path.filter(fragment => Object.values(sortTypes).includes(fragment))
-            console.log('hasSort :', hasSort)
-            console.log('path :', path)
-            if (path.length >= 2 && postTypes.includes(path[0]) && hasSort.length < 1) {
-                this._clearHero(this.$store)
-                this.loadPostData()
-            }
+            if (path.length < 2 || !postTypes.includes(to.params.type)) return
+            this._clearHero(this.$store)
+            this.loadPostData()
         },
     },
     created() {

vue-theme/src/utils/helpers.js

     return type.charAt(0).toUpperCase() + type.slice(1)
 }
 
-const dePluralize = type => {
-    return type[type.length - 1] === 's' ? type.slice(0, -1) : type
-}
-
 const sortTypes = {
     alpha: 'by-alpha',
     recent: 'by-recent',
 
 export {
     convertTitleCase,
-    dePluralize,
     typeFromRoute,
     sortTypes,
     postTypes,