Merge branch 'dev' of craft-in-america/vue-wp into master

vue-theme/src/components/navigation/navigation.vue

                     /* padding: 0 */
                     margin: 0
 
+    @media (max-width: $large)
+        .menu
+            display: none
+
     @media (min-width: $large)
         .menu
             display: flex
     @media (min-width:  $extra-large)
         .menu > ul
             max-width: $max-width
+
+    
 </style>

vue-theme/src/components/sidebars/sidebar.vue

 aside.sidebar
     section
         //- if not single layout with sorting
-        .shadow(v-if="['artist', 'exhibition', 'event', 'short', 'guide', 'object', 'publication', 'technique', 'post'].includes(type) && layout !== 'single'")
+        .shadow(v-if="shouldShowListSort.includes(type) && layout !== 'single'")
             h3.t-up sort {{ type }}
             ul.t-up
                 li(v-for="option in sortOptions")
                     router-link(:to="`/${type}/sorted/${sortTypes[option]}`")
                         p {{ option }}
-                //- exhibition, event list sidebar
-                template(v-if="['exhibition', 'event'].includes(type) && layout === 'list'")
                     router-link(:to="`/${type}`")
                         p by all
-                    router-link(:to="`/${type}/sorted/by-current-and-upcoming`")
+                    router-link(v-if="shouldShowDateSort.includes(type) && layout !== 'single'" :to="`/${type}/sorted/by-current-and-upcoming`")
                         p by current and upcoming
-                //- list sidebar 
-                template(v-if="['short', 'guide', 'publication', 'technique', 'post'].includes(type) && layout === 'list'")
-                    router-link(:to="`/${type}`")
-                        p by all
+        
+        //- if {{type}} sorted by-material show material options
+        .shadow(v-if="shouldShowMaterialSort.includes(type) && layout !== 'single'")
+            h3.t-up {{ type }} by material
+            ul.t-up
+                li
+                    template(v-for="material in materials") 
+                        router-link(:to="`/${type}/sorted/by-material#${material}`")
+                            p {{ material }}
+
+        //- if artist sorted by-alpha show alpha options           
+        .shadow(v-if="['artist'].includes(type) && layout !== 'single'")
+            h3.t-up {{ type }} alpha 
+            ul.t-up
+                li
+                    template(v-for="charaSet in charaSets") 
+                        router-link(:to="`/${type}/sorted/by-alpha#${charaSet[0]}`")
+                            p {{ charaSet }}
 
         //- p2p types and related posts
         .shadow(v-if="layout === 'single' && Object.keys(related).length" v-for="p2pPostType in Object.keys(related)")
 import relatedSidebar from './related'
 import exhibitionsSidebar from './exhibitions'
 import eventsSidebar from './events'
-// import shortsSidebar from './shorts'
-// import talksSidebar from './talks'
-// import postsSidebar from './posts'
-// import publicationsSidebar from './publications'
-// import articlesSidebar from './articles'
 
-import { sortTypes } from '@/utils/helpers'
+import { sortTypes, materials } from '@/utils/helpers'
 
 export default {
     props: {
         },
     },
     components: {
-        exhibitionsSidebar,
-        eventsSidebar,
-        relatedSidebar,
+        exhibitionsSidebar, eventsSidebar, relatedSidebar,
     },
     data() {
         return {
             sortTypes: {
-                alphabetized: `${sortTypes.alpha}`,
-                'by material': `${sortTypes.material}`,
-                'by artist': `${sortTypes.artist}`,
-                'by episode': `${sortTypes.episode}`,
-                'by artist type': `${sortTypes.subtype}`,
-                'by event type': `${sortTypes.subtype}`,
-                'by post type': `${sortTypes.subtype}`,
-                // 'by exhibition type': `${sortTypes.exhibitiontypes}`,
+                alphabetized: `${sortTypes.alpha}`,       //:0
+                'by material': `${sortTypes.material}`,   //:1
+                'by artist': `${sortTypes.artist}`,       //:2
+                'by episode': `${sortTypes.episode}`,     //:3
             },
+            charaSets: [
+                '0 a b', 'c d e', 'f g h',
+                'i j k', 'l m n', 'o p q',
+                'r s t', 'u v w', 'x y z'
+            ],
+            materials: materials,
+            shouldShowListSort: [
+                'artist', 'exhibition', 'event', 
+                'short', 'guide', 'object',
+                'publication', 'technique', 'post'
+            ],
+            shouldShowMaterialSort: [
+                'artist', 
+                'short', 'guide', 'object',
+                'technique',
+            ],
+            shouldShowAlphaSort: [
+                'artist'
+            ],
+            shouldShowDateSort: [
+                'exhibition', 'event'
+            ],
+            shouldShowTypeSort: [
+                'short', 'guide', 'object',
+                'publication', 'technique', 'post'
+            ]
         }
     },
     computed: {
                         Object.keys(this.sortTypes)[0],
                         Object.keys(this.sortTypes)[3],
                         Object.keys(this.sortTypes)[1],
-                        Object.keys(this.sortTypes)[4],
+                        `by ${this.type} type`,
                     ]
                     break
                 case 'post':
                     opts = [
-                        Object.keys(this.sortTypes)[6],
+                        `by ${this.type} type`,
                     ]
                     break
                 case 'short':

vue-theme/src/pages/index.vue

         section
             ul.flipped
                 li.post.shadow(v-for="type in thirdRow")
-                     .random--wrapper(v-for="post in randomPosts.filter(p => p.type == type)")
+                    .random--wrapper(v-for="post in [...randomPosts, ...allPages.filter(p => p.slug == 'center')].filter(p => p.type == type)")
                         card(:content="post" :type="type")
 </template>
 
         return {
             firstRow: ['episode', 'exhibition', 'event', 'short', 'post'],
             secondRow: 'artist', // This is only ONE post
-            thirdRow: ['object', 'technique', 'publication', 'center', 'guide'],
+            thirdRow: ['object', 'technique', 'publication', 'page', 'guide'],
             // ideal iteration
             // thirdRow: ['object', 'talks', 'publication', 'center', 'guide'],
         }

vue-theme/src/pages/list.vue

         ul.posts.f-col(v-if="posts && loaded" :class="{ 'is-grid': grid }")
             template(v-for="(post, i) in posts" :key="post.slug")
                 li.post.shadow(v-if="!post.inbetween" )
-                    card(:content="post" :type="type" :wide="isWide")
+                    card(:content="post" :type="post.type" :wide="isWide")
                 li.post.shadow.inbetween.t-up.f-row.w-max(v-else-if="post.inbetween" :id="post.slug")
                     p {{ post.slug }}
             
             return gridTypes.includes(this.type)
         },
         isSearch() {
-            return this.$route.path == '/search'
+            return this.searchTerm
         },
         isWide() {
             return wideTypes.includes(this.type)

vue-theme/src/store/modules/post.js

 }
 
 const actions = {
-    getAllPosts({ commit }, { sortType, params }) {
+    async getAllPosts({ commit }, { sortType, params }) {
         commit('CLEAR_POSTS')
         commit('POSTS_LOADED', false)
         const storeFetch = (posts => {
             commit('STORE_FETCHED_POSTS', { posts: repacked })
             commit('POSTS_LOADED', true)
         }) 
-        return api.getByType({ type: 'post', sort: sortType, params, cb: storeFetch })
+        return await api.getByType({ type: 'post', sort: sortType, params, cb: storeFetch })
     },
     getMorePosts({ commit }, { sortType, params }) {
         const storeFetch = (posts => {

vue-theme/src/store/modules/search.js

 
 const mutations = {
     ADD_TO_FETCHED_SEARCH_RESULTS(state, { searchResults }) {
-        console.log('adding results', searchResults)
         state.all = [...state.all, ...searchResults]
     },
     STORE_FETCHED_SEARCH_RESULTS(state, { searchResults }) {

vue-theme/src/utils/helpers.js

     return type.charAt(0).toUpperCase() + type.slice(1)
 }
 
+const materials = [
+    'clay',
+    'fiber',
+    'glass',
+    'metal',
+    'paper',
+    'wood'
+]
+
 const sortTypes = {
     alpha: 'by-alpha',
     recent: 'by-recent',
 
 export {
     convertTitleCase,
+    materials,
     sortTypes,
     postTypes,
     ytThumbnail,