mirror of
https://github.com/hanzoai/ui.git
synced 2026-11-21 00:18:41 +00:00
580 lines
17 KiB
TypeScript
580 lines
17 KiB
TypeScript
import {
|
|
computed,
|
|
makeObservable,
|
|
observable,
|
|
runInAction,
|
|
action,
|
|
toJS
|
|
} from 'mobx'
|
|
|
|
import { computedFn } from 'mobx-utils'
|
|
|
|
import type {
|
|
CommerceService,
|
|
Family,
|
|
LineItem,
|
|
SelectedPaths,
|
|
CategoryNode,
|
|
CategoryNodeRole,
|
|
Promo
|
|
} from '../../../types'
|
|
|
|
import {
|
|
createOrder as createOrderHelper,
|
|
updateOrderShippingInfo as updateOrderShippingInfoHelper,
|
|
updateOrderPaymentInfo as updateOrderPaymentInfoHelper
|
|
} from './order'
|
|
|
|
import ActualLineItem, { type ActualLineItemSnapshot } from './actual-line-item'
|
|
import { getParentPath } from '../../path-utils'
|
|
import { getErrorMessage } from '../../../util'
|
|
import sep from '../../sep'
|
|
|
|
import { getInstance } from './get-instance'
|
|
|
|
type StandaloneServiceOptions = {
|
|
dbName: string
|
|
ordersTable: string
|
|
localStorageKey: string
|
|
}
|
|
|
|
interface StandaloneServiceSnapshot {
|
|
items: ActualLineItemSnapshot[]
|
|
}
|
|
|
|
class StandaloneService
|
|
implements CommerceService
|
|
{
|
|
private _familyMap = new Map<string, Family>()
|
|
private _rootNode: CategoryNode
|
|
private _selectedPaths: SelectedPaths = {}
|
|
private _promo: Promo | null = null
|
|
|
|
private _options : StandaloneServiceOptions
|
|
private _currentFamily: Family | undefined = undefined
|
|
private _currentItem: ActualLineItem | undefined = undefined
|
|
|
|
constructor(
|
|
families: Family[],
|
|
rootNode: CategoryNode,
|
|
options: StandaloneServiceOptions,
|
|
serviceSnapshot?: StandaloneServiceSnapshot,
|
|
) {
|
|
|
|
this._rootNode = rootNode
|
|
this._options = options
|
|
|
|
families.forEach((fam) => {
|
|
fam.products = fam.products.map((p) => {
|
|
if (serviceSnapshot) {
|
|
const itemSnapshot = serviceSnapshot.items.find((is) => (is.sku === p.sku))
|
|
if (itemSnapshot) {
|
|
return new ActualLineItem(p, itemSnapshot)
|
|
}
|
|
}
|
|
return new ActualLineItem(p)
|
|
})
|
|
this._familyMap.set(fam.id, fam)
|
|
})
|
|
|
|
makeObservable<
|
|
StandaloneService,
|
|
'_selectedPaths' |
|
|
'_currentItem' |
|
|
'_currentFamily' |
|
|
'_promo' |
|
|
'_cartItems'
|
|
>(this, {
|
|
_selectedPaths : observable.deep,
|
|
_currentItem: observable.shallow,
|
|
_currentFamily: observable.shallow,
|
|
_promo: observable,
|
|
_cartItems: computed
|
|
})
|
|
|
|
makeObservable(this, {
|
|
|
|
setCurrentItem: action,
|
|
setCurrentFamily: action,
|
|
setAppliedPromo: action,
|
|
/* NOT selectPaths. It implements it's action mechanism */
|
|
|
|
cartItems: computed,
|
|
recentItem: computed,
|
|
cartQuantity: computed,
|
|
cartTotal: computed,
|
|
promoAppliedCartTotal: computed,
|
|
cartEmpty: computed,
|
|
selectedItems: computed,
|
|
selectedFamilies: computed,
|
|
hasSelection: computed,
|
|
currentItem: computed,
|
|
currentFamily: computed,
|
|
item: computed,
|
|
family: computed,
|
|
selectedPaths: computed,
|
|
appliedPromo: computed,
|
|
})
|
|
}
|
|
|
|
getFamilyById(id: string): Family | undefined {
|
|
return this._familyMap.get(id)
|
|
}
|
|
|
|
getNodeAtPath(skuPath: string): CategoryNode | undefined {
|
|
const toks = skuPath.split(sep.tok)
|
|
let level = 1
|
|
let node: CategoryNode | undefined = this._rootNode
|
|
do {
|
|
node = node!.subNodes?.find((sn) => (sn.skuToken === toks[level]))
|
|
level++
|
|
}
|
|
while (node && (level < toks.length))
|
|
return level === toks.length ? node : undefined
|
|
}
|
|
|
|
peek(skuPath: string): {
|
|
role: CategoryNodeRole
|
|
family: Family | undefined
|
|
families: Family[] | undefined
|
|
node: CategoryNode | undefined
|
|
item: LineItem | undefined
|
|
} | string /* OR error string */ {
|
|
|
|
const toks = skuPath.split(sep.tok)
|
|
let level: number
|
|
let node: CategoryNode | undefined = this._rootNode
|
|
let parent: CategoryNode | undefined = undefined
|
|
|
|
for (level = 1; level < toks.length && node && node.subNodes; level++) {
|
|
// https://stackoverflow.com/questions/62367492/inference-problem-referenced-directly-or-indirectly-in-its-own-initializer
|
|
const _node: CategoryNode | undefined =
|
|
node!.subNodes.find((sn) => (sn.skuToken === toks[level]))
|
|
if (!_node) {
|
|
return `service.peekAtNode: traversing '${skuPath}'... no CategoryNode at '${toks[level]}'!`
|
|
}
|
|
parent = node
|
|
node = _node
|
|
}
|
|
|
|
const atEnd = level === toks.length
|
|
const possibleSKU = level === toks.length - 1
|
|
|
|
let role: CategoryNodeRole = 'non-outermost'
|
|
let families: Family[] | undefined = undefined
|
|
let family: Family | undefined = undefined
|
|
let item: LineItem | undefined = undefined
|
|
let error: string | undefined = undefined
|
|
|
|
try {
|
|
if (node.subNodes && atEnd && node.outermost) {
|
|
role = 'multi-family'
|
|
families = node.subNodes.map((sub) => {
|
|
const familyId = skuPath + sep.tok + sub.skuToken
|
|
const fam = this._familyMap.get(familyId)
|
|
if (!fam) {
|
|
throw new Error(`service.peekAtNode: No Family under for CategoryNode '${skuPath}' with id ${familyId}!`)
|
|
}
|
|
return fam
|
|
})
|
|
}
|
|
else if (!node.subNodes && (atEnd || possibleSKU)) {
|
|
const _skuPath = (possibleSKU) ? getParentPath(skuPath) : skuPath
|
|
if (parent?.outermost) {
|
|
role = 'family-in-multi-family'
|
|
const fam = this._familyMap.get(_skuPath)
|
|
if (!fam) {
|
|
throw new Error(`service.peekAtNode: '${_skuPath}' graphs as a Family under a multi-family node, but no such family exists!`)
|
|
}
|
|
family = fam
|
|
const parentPath = getParentPath(_skuPath)
|
|
// get all siblings (subnodes of parent)
|
|
families = parent.subNodes!.map((sn) => {
|
|
const familyId = parentPath + sep.tok + sn.skuToken
|
|
const fam = this._familyMap.get(familyId)
|
|
if (!fam) {
|
|
throw new Error(`service.peekAtNode: No sibling Family for '${_skuPath}' with id '${familyId}'!`)
|
|
}
|
|
return fam
|
|
})
|
|
node = parent
|
|
}
|
|
else {
|
|
role = 'single-family'
|
|
const fam = this._familyMap.get(_skuPath)
|
|
if (!fam) {
|
|
throw new Error(`service.peekAtNode: '${_skuPath}' graphs as a single Family, but no such family exists!`)
|
|
}
|
|
family = fam
|
|
}
|
|
if (possibleSKU) {
|
|
const skuToTry = family.id + sep.tok + toks[toks.length - 1]
|
|
const _item = family.products.find((p) => (p.sku === skuToTry))
|
|
if (_item) {
|
|
item = _item as LineItem
|
|
}
|
|
else {
|
|
throw new Error(`service.peekAtNode: '${skuPath}' graphs as LineItem in Family '${family.id}', but no such sku exists there!`)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (e) {
|
|
error = getErrorMessage(e)
|
|
}
|
|
|
|
return error ?? {
|
|
role,
|
|
family,
|
|
families,
|
|
node,
|
|
item
|
|
}
|
|
}
|
|
|
|
getSelectedNodesAtLevel = computedFn((level: number): CategoryNode[] | undefined => {
|
|
|
|
let lvl = 1
|
|
let nodesAtLevel: CategoryNode[] | undefined = this._rootNode.subNodes
|
|
|
|
do {
|
|
let selectedAtLevel: CategoryNode[] | undefined = undefined
|
|
// If not specified, assume all
|
|
if (lvl in this._selectedPaths) {
|
|
selectedAtLevel = nodesAtLevel!.filter((n) => (this._selectedPaths[lvl].includes(n.skuToken)))
|
|
}
|
|
else {
|
|
selectedAtLevel = nodesAtLevel
|
|
}
|
|
let allSubsOfSelected: CategoryNode[] = []
|
|
selectedAtLevel?.forEach((n: CategoryNode) => {
|
|
if (n.subNodes) {
|
|
allSubsOfSelected = [...allSubsOfSelected, ...n.subNodes]
|
|
}
|
|
})
|
|
|
|
nodesAtLevel = allSubsOfSelected
|
|
lvl++
|
|
} while (nodesAtLevel.length > 0 && lvl <= level)
|
|
|
|
return (nodesAtLevel.length > 0 && ((lvl - 1) === level)) ? nodesAtLevel : undefined
|
|
})
|
|
|
|
get options() { return this._options}
|
|
|
|
//async createOrder(email: string, paymentMethod: string): Promise<string | undefined> {
|
|
async createOrder(email: string, name?: string): Promise<string | undefined> {
|
|
const snapshot = this.takeSnapshot()
|
|
const order = await createOrderHelper(email, snapshot.items, this._options, name) // didn't want to have two levels of 'items'
|
|
return order.id
|
|
}
|
|
|
|
// TODO: add shippingInfo type
|
|
async updateOrderShippingInfo(orderId: string, shippingInfo: any): Promise<void> {
|
|
updateOrderShippingInfoHelper(orderId, shippingInfo, this._options)
|
|
}
|
|
|
|
// TODO: add paymentInfo type
|
|
async updateOrderPaymentInfo(orderId: string, paymentInfo: any): Promise<void> {
|
|
updateOrderPaymentInfoHelper(orderId, paymentInfo, this._options)
|
|
}
|
|
// Might as well use the ordered set.
|
|
takeSnapshot = (): StandaloneServiceSnapshot => ({
|
|
items : (this.cartItems as ActualLineItem[]).map((it) => (it.takeSnapshot(this)))
|
|
})
|
|
|
|
// last cartItem whose quantity was modified (undefined if cartEmpty)
|
|
get recentItem(): { item: LineItem, modified: number} | undefined {
|
|
|
|
if (this.cartEmpty) return undefined;
|
|
|
|
const mostRecent = this._cartItems.reduce(
|
|
(newest, item) => ((!newest) ? item : (
|
|
(item as ActualLineItem).timeModified > (newest as ActualLineItem).timeModified) ? item : newest
|
|
),
|
|
undefined as LineItem | undefined
|
|
)
|
|
return { item: mostRecent!, modified: (mostRecent! as ActualLineItem).timeModified }
|
|
}
|
|
|
|
private get _cartItems(): LineItem[] {
|
|
let result: LineItem[] = []
|
|
this._familyMap.forEach((fam) => {
|
|
result = [...result, ...(fam.products as LineItem[]).filter((item) => (item.isInCart))]
|
|
})
|
|
return result
|
|
}
|
|
|
|
get cartItems(): LineItem[] {
|
|
return this._cartItems.sort((it1, it2) => ((it1 as ActualLineItem).timeAdded - (it2 as ActualLineItem).timeAdded))
|
|
}
|
|
|
|
|
|
|
|
get cartEmpty(): boolean {
|
|
return this._cartItems.length === 0
|
|
}
|
|
|
|
get cartTotal(): number {
|
|
return this._cartItems.reduce(
|
|
(total, item) => (total + item.price * item.quantity),
|
|
0
|
|
)
|
|
}
|
|
|
|
_promoValue_unsafe(value: number): number {
|
|
if (this._promo!.type === 'percent') {
|
|
return value * (1 - this._promo!.value / 100)
|
|
}
|
|
return value - this._promo!.value
|
|
}
|
|
|
|
get promoAppliedCartTotal(): number {
|
|
if (!this._promo) {
|
|
return this.cartTotal
|
|
}
|
|
if (!this._promo.skus) {
|
|
return this._promoValue_unsafe(this.cartTotal)
|
|
}
|
|
let total = this._cartItems.reduce(
|
|
(total, item) => {
|
|
const itemPrice = this._promo!.skus!.includes(item.sku) ?
|
|
this._promoValue_unsafe(item.price)
|
|
:
|
|
item.price
|
|
return total + itemPrice * item.quantity
|
|
},
|
|
0
|
|
)
|
|
return total
|
|
}
|
|
|
|
itemPromoPrice(item: LineItem): number | undefined {
|
|
if (this._promo && (!this._promo.skus || this._promo.skus.includes(item.sku) )) {
|
|
return this._promoValue_unsafe(item.price)
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
get cartQuantity(): number {
|
|
return this.cartItems.reduce(
|
|
(total, item) => (total + item.quantity),
|
|
0
|
|
)
|
|
}
|
|
|
|
get appliedPromo(): Promo | null {
|
|
return this._promo
|
|
}
|
|
|
|
setAppliedPromo(promo: Promo | null): void {
|
|
this._promo = promo
|
|
}
|
|
|
|
getItemBySku = (skuToFind: string | undefined): LineItem | undefined => {
|
|
|
|
if (skuToFind === undefined || skuToFind.length === 0) {
|
|
return undefined
|
|
}
|
|
// Self-calling
|
|
const found = ((): ActualLineItem | undefined => {
|
|
|
|
const familiesTried: string[] = []
|
|
if (this.selectedFamilies && this.selectedFamilies.length > 0) {
|
|
for (let family of this.selectedFamilies) {
|
|
familiesTried.push(family.id)
|
|
const foundItem = family.products.find((p) => (p.sku === skuToFind))
|
|
if (foundItem) {
|
|
return foundItem as ActualLineItem
|
|
}
|
|
}
|
|
}
|
|
for( const [familyId, family] of this._familyMap.entries()) {
|
|
if (familiesTried.includes(familyId)) continue
|
|
const foundItem = family.products.find((p) => (p.sku === skuToFind)) as ActualLineItem | undefined
|
|
if (foundItem) {
|
|
return foundItem as ActualLineItem
|
|
}
|
|
}
|
|
return undefined
|
|
})(); // Self-calling, necessary semi
|
|
|
|
return found
|
|
}
|
|
|
|
setCurrentItem = (skuToFind: string | undefined): boolean => {
|
|
|
|
if (skuToFind === undefined || skuToFind.length === 0) {
|
|
this._currentItem = undefined
|
|
return true
|
|
}
|
|
// self calling function
|
|
this._currentItem = this.getItemBySku(skuToFind) as ActualLineItem | undefined
|
|
this.setCurrentFamily(this._currentItem ? this._currentItem.familyId : undefined)
|
|
return !!this._currentItem
|
|
}
|
|
|
|
/* for ObsLineItemRef */
|
|
get item(): LineItem | undefined {
|
|
return this._currentItem
|
|
}
|
|
|
|
get currentItem(): LineItem | undefined {
|
|
return this._currentItem
|
|
}
|
|
|
|
setCurrentFamily(id: string | undefined): boolean {
|
|
|
|
if (id === undefined || id.length === 0) {
|
|
this._currentFamily = undefined
|
|
return true
|
|
}
|
|
|
|
const fam = this._familyMap.get(id)
|
|
this._currentFamily = fam // undef ok
|
|
|
|
if (
|
|
this._currentFamily &&
|
|
this._currentItem &&
|
|
this._currentItem.familyId !== this._currentFamily.id
|
|
) {
|
|
this._currentItem = undefined
|
|
}
|
|
|
|
return !!this._currentFamily
|
|
}
|
|
|
|
get currentFamily(): Family | undefined {
|
|
return this._currentFamily
|
|
}
|
|
|
|
/* for ObsFamilyRef */
|
|
get family(): Family | undefined {
|
|
return this._currentFamily
|
|
}
|
|
|
|
selectPaths(sel: SelectedPaths): Family[] {
|
|
runInAction (() => {
|
|
this._selectedPaths = this._processAndValidate(sel)
|
|
})
|
|
return this.selectedFamilies
|
|
}
|
|
|
|
selectPath(skuPath: string): Family[] {
|
|
const toks = skuPath.split(sep.tok)
|
|
const highestLevel = toks.length - 1
|
|
const fsv: SelectedPaths = {}
|
|
for (let level = 1; level <= highestLevel; level++ ) {
|
|
fsv[level] = [toks[level]]
|
|
}
|
|
return this.selectPaths(fsv)
|
|
}
|
|
|
|
get selectedPaths(): SelectedPaths {
|
|
const result: SelectedPaths = {}
|
|
for( let level in this._selectedPaths ) {
|
|
result[level] = [...this._selectedPaths[level]]
|
|
}
|
|
return result
|
|
}
|
|
|
|
get selectedFamilies(): Family[] {
|
|
if (Object.keys(toJS(this._selectedPaths)).length === 0) {
|
|
// FacetsDesc have never been set or unset, so cannot evaluate them
|
|
return []
|
|
}
|
|
|
|
return this._rootNode.subNodes!.reduce(
|
|
(acc: Family[], subFacet: CategoryNode) => (
|
|
// Pass the root token as a one member array
|
|
this._reduceNode([this._rootNode.skuToken], acc, subFacet)
|
|
),
|
|
[]
|
|
)
|
|
}
|
|
|
|
private _reduceNode(parentPath: string[], acc: Family[], node: CategoryNode): Family[] {
|
|
const path = [...parentPath, node.skuToken] // Don't mutate original please :)
|
|
const level = path.length - 1
|
|
// If there is no token array supplied for this level,
|
|
// assume all are specified. Otherwise, see if the
|
|
// current node is in the array
|
|
const specified = (
|
|
!this._selectedPaths[level]
|
|
||
|
|
this._selectedPaths[level].includes(node.skuToken)
|
|
)
|
|
if (specified) {
|
|
// Process subnodes
|
|
if (node.subNodes && node.subNodes.length > 0) {
|
|
return node.subNodes.reduce((acc, n) => (
|
|
this._reduceNode(path, acc, n)
|
|
)
|
|
, acc)
|
|
}
|
|
// Process leaf
|
|
const fam = this._familyMap.get(path.join(sep.tok))
|
|
if (!fam) {
|
|
throw new Error("selectedFamilies WTF?!" + path.join(sep.tok))
|
|
}
|
|
acc.push(fam)
|
|
}
|
|
return acc
|
|
}
|
|
|
|
private _processAndValidate(partial: SelectedPaths): SelectedPaths {
|
|
|
|
const result: SelectedPaths = {}
|
|
|
|
let level = 1
|
|
let currentSet = this._rootNode.subNodes!
|
|
|
|
while (true) {
|
|
let possibleCurrent = currentSet.map((el) => (el.skuToken))
|
|
const validTokens = !partial[level] ? undefined : partial[level].filter((tok) => possibleCurrent.includes(tok))
|
|
if (!validTokens) {
|
|
break
|
|
}
|
|
result[level] = validTokens
|
|
currentSet = validTokens.map((tok) => {
|
|
const fd = currentSet.find((node) => ( node.skuToken === tok ))
|
|
return (fd && fd.subNodes && fd.subNodes.length > 0) ? fd.subNodes : []
|
|
}).flat()
|
|
level++
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
get selectedItems(): LineItem[] {
|
|
if (Object.keys(toJS(this._selectedPaths)).length === 0) {
|
|
// FacetsDesc have never been set or unset, so cannot evaluate them
|
|
return []
|
|
}
|
|
|
|
return this.selectedFamilies.reduce(
|
|
(allProducts, fam) => ([...allProducts, ...(fam.products as LineItem[])]), [] as LineItem[])
|
|
}
|
|
|
|
get hasSelection(): boolean {
|
|
return this.selectedFamilies.length > 0
|
|
}
|
|
|
|
getFamilySubtotal(familyId: string): number {
|
|
const c = this._familyMap.get(familyId)!
|
|
return (c.products as LineItem[]).reduce(
|
|
// avoid floating point bs around zero
|
|
(total, item) => (item.quantity > 0 ? total + item.price * item.quantity : total),
|
|
0
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
export {
|
|
type StandaloneServiceOptions,
|
|
type StandaloneServiceSnapshot,
|
|
StandaloneService,
|
|
getInstance
|
|
}
|