@app-brew/brewery 1.0.0

package/src/state/src/lib/filter.ts

@@ -0,0 +1,343 @@
+import {
+  CollectionId,
+  CollectionProductSortKeys,
+  CollectionSortOptions,
+  Label,
+  ModuleKeys,
+  SearchSortOptions,
+  SortAndFilterConfig,
+  SortKey,
+  SortKeys,
+  queryData,
+} from '@gauntlet/types'
+import base64 from 'react-native-base64'
+import { RouteSlice } from '..'
+import { CollectionSlice } from './collections'
+import { SEARCH_COLLECTION_ID, SearchSlice } from './search'
+import { StoreSlice } from './types'
+
+type FilterSettings = {
+  labels: Record<SortKey, Label>
+  collectionSortOptions: CollectionSortOptions
+  searchSortOptions: SearchSortOptions
+  searchFilterOptions?: {
+    default?: Record<string, any> | null
+  }
+  collectionFilterOptions?: {
+    default?: Record<string, any> | null
+  }
+}
+export interface FilterData {
+  sortKey?: SortKeys | CollectionProductSortKeys | string
+  price: [number, number | undefined][]
+  query: queryData
+  static: undefined | SortAndFilterConfig['source']['staticData']
+  initialFilterData?: Omit<FilterData, 'status'>
+  status: 'init' | 'loading' | 'idle'
+}
+export interface FilterState {
+  settings: FilterSettings
+  collections: Record<string, FilterData>
+}
+type FilterParam = {
+  filter?: {
+    default?: Record<string, any>
+  }
+}
+export interface FilterActions {
+  getFilterSettings: () => FilterSettings
+  setSortKey: (collectionId: string, key: string) => void
+  setQuery: (
+    collectionId: string,
+    data: FilterData['query'],
+    price?: FilterData['price']
+  ) => void
+  resetCollection: (
+    collectionId: string,
+    defaultSortKey: string,
+    defaultFilterOptions?: Record<string, any>
+  ) => void
+  resetFilters: (
+    collectionId: string,
+    defaultInitialFilterData?: FilterData
+  ) => void
+  updateCollection: (
+    collectionId: string,
+    data: Partial<{
+      sortKey: SortKeys | CollectionProductSortKeys | string
+      price: [number, number | undefined][]
+      query: queryData
+      static?: SortAndFilterConfig['source']['staticData']
+    }>
+  ) => void
+  updateFilterStatus: (
+    collectionId: string,
+    status: FilterData['status']
+  ) => void
+  refreshSearch: () => void
+  setStaticData: (
+    collectionId: string,
+    data: SortAndFilterConfig['source']['staticData']
+  ) => void
+  setFilterSettings: (
+    module: ModuleKeys,
+    settings: (
+      | FilterSettings['searchSortOptions']
+      | FilterSettings['collectionSortOptions']
+    ) &
+      FilterParam
+  ) => void
+  getSortKey: (id?: CollectionId, defaultSort?: string) => SortKey | string
+  getSortOptions: () => Record<string, string>
+  getDefaultSortKey: (collectionId: string) => string | undefined
+}
+
+export interface FilterSlice {
+  filter: FilterState & FilterActions
+}
+
+const initialState: FilterState = {
+  settings: {
+    labels: {},
+    collectionSortOptions: {
+      values: null,
+      default: null,
+    },
+    searchSortOptions: {
+      values: null,
+      default: null,
+    },
+    collectionFilterOptions: {
+      default: null,
+    },
+    searchFilterOptions: {
+      default: null,
+    },
+  },
+  collections: {},
+}
+
+export const createFilterSlice: StoreSlice<
+  FilterSlice,
+  FilterSlice & SearchSlice & RouteSlice & CollectionSlice
+> = (set, get) => ({
+  filter: {
+    ...initialState,
+    // this is not used anywhere
+    getSortKey: (collectionId, defaultSort) => {
+      const {
+        settings: { defaultSortOrder },
+        sortKey,
+      } = get().filter
+      if (sortKey) return sortKey
+      if (!collectionId) return SortKeys.EMPTY
+      if (!defaultSortOrder) return defaultSort ?? SortKeys.EMPTY
+      if (collectionId === 'search_collection') {
+        return defaultSortOrder[collectionId] ?? SortKeys.EMPTY
+      }
+      let gid = collectionId
+      if (!collectionId.startsWith('gid')) gid = base64.decode(collectionId)
+      const id = gid.split('/').reverse()[0]
+      const res =
+        defaultSortOrder[id] ?? defaultSortOrder['all'] ?? SortKeys.EMPTY
+      return res
+    },
+    setSortKey: (collectionId, key) => {
+      set((state) => {
+        if (state.filter.collections[collectionId]) {
+          state.filter.collections[collectionId].sortKey = key
+        }
+      })
+      get().filter.refreshSearch()
+    },
+    setQuery: (collectionId, data, price) => {
+      set((s) => {
+        if (collectionId && s.filter.collections[collectionId]) {
+          s.filter.collections[collectionId].query = data
+          if (price) s.filter.collections[collectionId].price = price
+        }
+      })
+      get().filter.refreshSearch()
+    },
+
+    refreshSearch: () => {
+      const routeName = get().route.name
+      if (routeName === 'search') {
+        get().search.getSearchResults()
+      }
+    },
+
+    setStaticData: (collectionId, data) => {
+      set((state) => {
+        if (!state.filter.collections[collectionId]) return
+        if (state.filter.collections[collectionId].static) {
+          const obj = {}
+          data.forEach((item) => {
+            if (item.type === 'range') {
+              const stateItem = state.filter.collections[
+                collectionId
+              ].static.filter((i) => i.key === item.key)[0]
+              if (stateItem && item)
+                obj[item.key] = Object.assign({}, item, {
+                  data: {
+                    min: 0,
+                    max: Math.max(stateItem?.data?.max, item?.data?.max),
+                  },
+                })
+            } else obj[item.key] = item
+          })
+          state.filter.collections[collectionId].static = Object.values(obj)
+          state.filter.collections[collectionId].status = 'idle'
+        } else {
+          state.filter.collections[collectionId].static = data
+          state.filter.collections[collectionId].initialFilterData = {
+            static: data,
+            query: state.filter.collections[collectionId].query,
+            price: state.filter.collections[collectionId].price,
+            sortKey: state.filter.collections[collectionId].sortKey,
+          }
+          state.filter.collections[collectionId].status = 'idle'
+        }
+      })
+    },
+    setFilterSettings: (module, settings) => {
+      set((state) => {
+        if (module === 'SEARCH') {
+          state.filter.settings.searchSortOptions = {
+            values: (settings as SearchSortOptions)?.values,
+            default: (settings as SearchSortOptions)?.default,
+            collections: (settings as SearchSortOptions)?.collections,
+          }
+          state.filter.settings.searchFilterOptions = {
+            default: settings?.filter?.default,
+          }
+        } else {
+          state.filter.settings.collectionSortOptions = {
+            values: settings?.values,
+            default: settings?.default,
+          }
+
+          state.filter.settings.collectionFilterOptions = {
+            default: settings?.filter?.default,
+          }
+        }
+      })
+    },
+    getSortOptions: () => {
+      return {
+        'created-descending': 'Newly Added',
+        manual: 'Curated For You',
+        'best-selling': 'Best Seller',
+        'price-descending': 'Price (High to Low)',
+        'price-ascending': 'Price (Low to High)',
+        'extra-sort1-ascending': 'Last Chance',
+        relevance: 'Relevance',
+        'extra-sort2-descending': 'Custom',
+      }
+    },
+    resetCollection: (collectionId, defaultSortKey, defaultFilterOptions) => {
+      set((s) => {
+        s.filter.collections[collectionId] = {
+          sortKey: defaultSortKey,
+          price: defaultFilterOptions?.['price'] ?? [],
+          query: defaultFilterOptions?.['query'] ?? {},
+          static: undefined,
+          initialFilterData:
+            s.filter.collections[collectionId]?.initialFilterData,
+          status: 'init',
+        }
+      })
+      if (collectionId === SEARCH_COLLECTION_ID) {
+        get().filter.refreshSearch()
+      }
+    },
+    // this only resets the filter, keeps sort as it is
+    resetFilters: (collectionId) => {
+      set((s) => {
+        const initialFilterData =
+          s.filter.collections[collectionId].initialFilterData
+        if (!initialFilterData) return
+        const collection = s.filter.collections[collectionId]
+        collection.query = initialFilterData.query
+        collection.price = initialFilterData.price
+        collection.static = initialFilterData.static
+      })
+      if (collectionId === SEARCH_COLLECTION_ID) {
+        get().filter.refreshSearch()
+      }
+    },
+
+    updateFilterStatus: (collectionId, status) => {
+      set((s) => {
+        s.filter.collections[collectionId].status = status
+      })
+    },
+    updateCollection: (collectionId, data) => {
+      set((s) => {
+        const collection = s.filter.collections[collectionId]
+
+        if (collection) {
+          if (collection.static) {
+            s.filter.collections[collectionId] = {
+              ...collection,
+              ...data,
+              status: 'idle',
+            }
+          } else {
+            s.filter.collections[collectionId] = {
+              ...collection,
+              ...data,
+              initialFilterData: {
+                static: data.static,
+                query: collection.query,
+                price: collection.price,
+                sortKey: collection.sortKey,
+              },
+              status: 'idle',
+            }
+          }
+        }
+      })
+    },
+
+    getDefaultSortKey: (collectionId) => {
+      if (collectionId === SEARCH_COLLECTION_ID) {
+        return get().filter.settings.searchSortOptions.default
+      }
+      return (
+        (
+          get().filter.settings.collectionSortOptions.default as Record<
+            string,
+            string
+          >
+        )[collectionId] ?? get().filter.settings.collectionSortOptions.default
+      )
+    },
+
+    getFilterSettings: () => {
+      return get().filter.settings
+    },
+  },
+})
+
+export function genFilterCacheKey(
+  id: string,
+  sortKey: SortKeys | CollectionProductSortKeys | string,
+  price: [number, number | undefined][],
+  query: queryData,
+  prefix = ''
+) {
+  if (id === SEARCH_COLLECTION_ID) return SEARCH_COLLECTION_ID
+  let key = `${prefix}${id}:${sortKey}`
+  if (price.length > 0) {
+    price.forEach((item) => {
+      key += `:${item[1] || -1}/${item[1] || -1}`
+    })
+  }
+  Object.entries(query).forEach(([objKey, value]) => {
+    if (value.length > 0) {
+      key += `${objKey}/${JSON.stringify(value)}`
+    }
+  })
+  return key
+}

package/src/state/src/lib/gift-wrap.ts

@@ -0,0 +1,184 @@
+import { BaseLineItem, LineItem } from '@gauntlet/types'
+import { BundleSlice } from './bundle'
+import { CartSlice } from './cart'
+import { StoreSlice } from './types'
+
+export interface GiftWrapState {
+  items: BaseLineItem[]
+  itemsInCart: LineItem[]
+  itemsInBundle: BaseLineItem[]
+}
+
+export interface GiftWrapActions {
+  init: (bundleId: string) => void
+  getItem: (variantIds: string[], bundleId?: string) => BaseLineItem | undefined
+  addItem: (item: BaseLineItem) => void
+  removeItem: (variantId: string) => void
+  updateItem: (item: BaseLineItem) => void
+  changeVariant: (currentVariantId: string, prevVariantId: string) => void
+  moveItemsToCart: () => Promise<void>
+  moveItemsToBundle: () => void
+  reset: () => Promise<void>
+}
+
+export interface GiftWrapSlice {
+  giftWrap: GiftWrapState & GiftWrapActions
+}
+
+export const createGiftWrapSlice: StoreSlice<
+  GiftWrapSlice,
+  GiftWrapSlice & CartSlice & BundleSlice
+> = (set, get) => ({
+  giftWrap: {
+    items: [],
+    itemsInCart: [],
+    itemsInBundle: [],
+    init: (bundleId?: string) => {
+      const cart = get().cart
+      const bundle = get().bundle
+      const current = get().giftWrap
+      const items: BaseLineItem[] = []
+      const itemsInCart: LineItem[] = []
+      const itemsInBundle: BaseLineItem[] = []
+      cart.data.lineItems.forEach((lineItem) => {
+        if (lineItem.customAttributes?.isGiftWrap === 'true') {
+          if (!lineItem.customAttributes?.bundleId && !bundleId) {
+            items.push(lineItem)
+            itemsInCart.push(lineItem)
+          } else if (
+            bundleId &&
+            lineItem.customAttributes?.bundleId === bundleId
+          ) {
+            items.push(lineItem)
+            itemsInBundle.push(lineItem)
+          }
+        }
+      })
+      bundle.items.forEach((item) => {
+        if (bundleId && item.customAttributes?.bundleId === bundleId) {
+          items.push(item)
+          itemsInBundle.push(item)
+        }
+      })
+      set({
+        giftWrap: {
+          ...current,
+          items,
+          itemsInCart,
+          itemsInBundle,
+        },
+      })
+    },
+    getItem: (variantIds: string[], bundleId?: string) => {
+      const current = get().giftWrap
+      for (const item of current.items) {
+        if (variantIds.includes(item.variantId)) {
+          if (bundleId && item.customAttributes?.bundleId !== bundleId) {
+            return undefined
+          }
+          return item
+        }
+      }
+      return undefined
+    },
+    addItem: (item: BaseLineItem) => {
+      const current = get().giftWrap
+      const giftWrapItems = [...current.items]
+      giftWrapItems.push(item)
+      set({
+        giftWrap: {
+          ...current,
+          items: giftWrapItems,
+        },
+      })
+    },
+    removeItem: (variantId: string) => {
+      const current = get().giftWrap
+      let giftWrapItems = [...current.items]
+      giftWrapItems = giftWrapItems.filter((giftWrapItem) => {
+        return giftWrapItem.variantId !== variantId
+      })
+      set({
+        giftWrap: {
+          ...current,
+          items: giftWrapItems,
+        },
+      })
+    },
+    updateItem: (item: BaseLineItem) => {
+      const current = get().giftWrap
+      let giftWrapItems = [...current.items]
+      giftWrapItems = giftWrapItems.map((giftWrapItem) => {
+        if (giftWrapItem.variantId === item.variantId) {
+          return item
+        }
+        return giftWrapItem
+      })
+      set({
+        giftWrap: {
+          ...current,
+          items: giftWrapItems,
+        },
+      })
+    },
+    changeVariant: (currentVariantId: string, prevVariantId: string) => {
+      const current = get().giftWrap
+      const giftWrapItems = [...current.items]
+      for (const giftWrapItem of giftWrapItems) {
+        if (giftWrapItem.variantId === prevVariantId) {
+          giftWrapItem.variantId = currentVariantId
+          break
+        }
+      }
+      set({
+        giftWrap: {
+          ...current,
+          items: giftWrapItems,
+        },
+      })
+    },
+    moveItemsToCart: async () => {
+      const current = get().giftWrap
+      const { addItemsToCart, removeItemsFromCart } = get().cart
+      if (current.itemsInCart.length > 0) {
+        await removeItemsFromCart(current.itemsInCart.map((item) => item.id))
+      }
+      const cart = await addItemsToCart(current.items)
+      const variantIds = current.items.map((item) => item.variantId)
+      set({
+        giftWrap: {
+          ...current,
+          itemsInCart:
+            cart?.lineItems.filter((lineItem) => {
+              return variantIds.includes(lineItem.variantId)
+            }) || [],
+        },
+      })
+    },
+    moveItemsToBundle: () => {
+      const current = get().giftWrap
+      const { addItems, removeItems } = get().bundle
+      if (current.itemsInBundle.length > 0) {
+        removeItems(current.itemsInBundle.map((item) => item.variantId))
+      }
+      addItems(current.items)
+      set({
+        giftWrap: {
+          ...current,
+          itemsInBundle: current.items,
+        },
+      })
+    },
+    reset: async () => {
+      const current = get().giftWrap
+      set({
+        giftWrap: {
+          ...current,
+          items: [],
+          itemsInCart: [],
+          itemsInBundle: [],
+        },
+      })
+    },
+  },
+})

package/src/state/src/lib/google-signin.ts

@@ -0,0 +1,3 @@
+import { GoogleSignin } from '@react-native-google-signin/google-signin'
+
+export const googleSignin = GoogleSignin

package/src/state/src/lib/google-signin.web.ts

@@ -0,0 +1 @@
+export const googleSignin = {}

package/src/state/src/lib/hooks/block.ts

@@ -0,0 +1,136 @@
+import React, { useMemo } from 'react'
+import { BlockConfig } from '@gauntlet/types'
+import { useAppStore } from '../store'
+import { useTheme } from './hooks'
+
+function mergeArraysWithUniqueValues() {
+  return function (target: Array<unknown>, source: Array<unknown>) {
+    const c = [...target, ...source]
+    return c.filter((item, pos) => c.indexOf(item) === pos)
+  }
+}
+
+const deepmerge = require('@fastify/deepmerge')({
+  all: true,
+  mergeArray: mergeArraysWithUniqueValues,
+})
+
+const isEmptyObject = (obj: object) => Object.keys(obj).length === 0
+
+function cloneAndRemoveLayout(settings: { [x: string]: any }) {
+  const clone = {} as Record<string, any>
+  for (const key of Object.keys(settings ?? {})) {
+    if (key !== 'layout') {
+      clone[key] = settings[key]
+    }
+  }
+  return clone
+}
+
+export function useBlockStyle(
+  block: BlockConfig,
+  options?: { themeKey?: string }
+) {
+  const componentId = block.componentId
+  const variant = block.variant
+  const key = options && options?.themeKey
+  const theme = useTheme()
+  const mergedStyle = useMemo(() => {
+    if (!theme) return block.style
+    const themeBlockStyle =
+      theme[`${componentId}--${variant}`] ?? theme[`${componentId}`]
+    const themeStyle = key ? theme[key] ?? {} : {}
+
+    let mergedThemeStyleAndThemeBlockStyle = null
+    if (themeStyle && themeBlockStyle) {
+      mergedThemeStyleAndThemeBlockStyle = deepmerge(
+        themeStyle,
+        themeBlockStyle
+      )
+    }
+    if (!block.style) {
+      if (!themeStyle && !themeBlockStyle) return {}
+      if (!themeStyle && themeBlockStyle) return themeBlockStyle
+      if (themeStyle && !themeBlockStyle) return themeStyle
+
+      return mergedThemeStyleAndThemeBlockStyle
+    }
+    if (block.style && isEmptyObject(block.style)) {
+      if (!themeStyle && !themeBlockStyle) return {}
+      if (!themeStyle && themeBlockStyle) return themeBlockStyle
+      if (themeStyle && !themeBlockStyle) return themeStyle
+      return mergedThemeStyleAndThemeBlockStyle
+    }
+    if (block.style) {
+      if (!themeStyle && !themeBlockStyle) return block.style
+      if (!themeStyle && themeBlockStyle)
+        return deepmerge(themeBlockStyle, block.style)
+      if (themeStyle && !themeBlockStyle)
+        return deepmerge(themeStyle, block.style)
+      return deepmerge(mergedThemeStyleAndThemeBlockStyle, block.style)
+    }
+    console.error(
+      'Style is not defined or empty in block, theme and theme-variant'
+    )
+    return {}
+  }, [block.style, componentId, theme, key, variant])
+  return mergedStyle
+}
+
+export function useBlockSettings<T extends BlockConfig = BlockConfig>(
+  block: BlockConfig,
+  options?: { extends?: string }
+) {
+  const componentId = block.componentId
+  const variant = block.variant
+  const key = options && options?.extends
+  const settings = useAppStore(
+    React.useCallback((store) => store.config.data?.settings, [])
+  )
+  const mergedSettings = React.useMemo(() => {
+    if (!block) {
+      console.error('no block passed to useBlockSettings')
+      return {
+        options: {},
+        source: {},
+        layout: null,
+      }
+    }
+
+    const localSettings = {
+      options: block.options ?? {},
+      source: block.source ?? {},
+    }
+    if (!settings) return localSettings
+    const parentSettings = key ? settings[key] ?? {} : {}
+    const globalSettings =
+      settings[`${componentId}--${variant}`] ?? settings[`${componentId}`] ?? {}
+
+    const base = {
+      layout:
+        block.layout ?? parentSettings.layout ?? globalSettings.layout ?? null,
+    }
+
+    const parentSettingsWithoutLayout = cloneAndRemoveLayout(parentSettings)
+    const globalSettingsWithoutLayout = cloneAndRemoveLayout(globalSettings)
+    if (!parentSettingsWithoutLayout && !globalSettingsWithoutLayout)
+      return deepmerge(base, localSettings)
+    if (!parentSettingsWithoutLayout && globalSettingsWithoutLayout) {
+      return deepmerge(base, globalSettingsWithoutLayout, localSettings)
+    }
+    if (parentSettingsWithoutLayout && !globalSettingsWithoutLayout) {
+      return deepmerge(base, parentSettingsWithoutLayout, localSettings)
+    }
+
+    /**
+     * Passing a key in an object in deepmerge with explicit undefined value will remove the key from the object
+     */
+    return deepmerge(
+      base,
+      parentSettingsWithoutLayout,
+      globalSettingsWithoutLayout,
+      localSettings
+    )
+  }, [block, componentId, key, settings, variant])
+  return mergedSettings as Pick<T, 'source' | 'options' | 'layout'>
+}