The complete open source platform to run your entire marketplace. Storefront, vendor panel, admin console, and integrations in one enterprise-grade platform you own.
TypeScript b2b-marketplacecomposable-commerceecommerceenterpriseheadless-commercemarketplacemedusamedusajsmulti-vendortypescript
import type { UniqueIdentifier } from "@dnd-kit/core"
import { arrayMove } from "@dnd-kit/sortable"
import type { FlattenedItem, TreeItem } from "./types"
export const iOS = /iPad|iPhone|iPod/.test(navigator.platform)
function getDragDepth(offset: number, indentationWidth: number) {
return Math.round(offset / indentationWidth)
}
export function getProjection(
items: FlattenedItem[],
activeId: UniqueIdentifier,
overId: UniqueIdentifier,
dragOffset: number,
indentationWidth: number
) {
const overItemIndex = items.findIndex(({ id }) => id === overId)
const activeItemIndex = items.findIndex(({ id }) => id === activeId)
const activeItem = items[activeItemIndex]
const newItems = arrayMove(items, activeItemIndex, overItemIndex)
const previousItem = newItems[overItemIndex - 1]
const nextItem = newItems[overItemIndex + 1]
const dragDepth = getDragDepth(dragOffset, indentationWidth)
const projectedDepth = activeItem.depth + dragDepth
const maxDepth = getMaxDepth({
previousItem,
})
const minDepth = getMinDepth({ nextItem })
let depth = projectedDepth
if (projectedDepth >= maxDepth) {
depth = maxDepth
} else if (projectedDepth < minDepth) {
depth = minDepth
}
return { depth, maxDepth, minDepth, parentId: getParentId() }
function getParentId() {
if (depth === 0 || !previousItem) {
return null
}
if (depth === previousItem.depth) {
return previousItem.parentId
}
if (depth > previousItem.depth) {
return previousItem.id
}
const newParent = newItems
.slice(0, overItemIndex)
.reverse()
.find((item) => item.depth === depth)?.parentId
return newParent ?? null
}
}
function getMaxDepth({ previousItem }: { previousItem: FlattenedItem }) {
if (previousItem) {
return previousItem.depth + 1
}
return 0
}
function getMinDepth({ nextItem }: { nextItem: FlattenedItem }) {
if (nextItem) {
return nextItem.depth
}
return 0
}
function flatten<T extends TreeItem>(
items: T[],
parentId: UniqueIdentifier | null = null,
depth = 0,
childrenProp: string
): FlattenedItem[] {
return items.reduce<FlattenedItem[]>((acc, item, index) => {
const children = (item[childrenProp] || []) as T[]
return [
...acc,
{ ...item, parentId, depth, index },
...flatten(children, item.id, depth + 1, childrenProp),
]
}, [])
}
export function flattenTree<T extends TreeItem>(
items: T[],
childrenProp: string
): FlattenedItem[] {
return flatten(items, undefined, undefined, childrenProp)
}
type ItemUpdate = {
id: UniqueIdentifier
parentId: UniqueIdentifier | null
index: number
}
export function buildTree<T extends TreeItem>(
flattenedItems: FlattenedItem[],
newIndex: number,
childrenProp: string
): { items: T[]; update: ItemUpdate } {
const root = { id: "root", [childrenProp]: [] } as T
const nodes: Record<string, T> = { [root.id]: root }
const items = flattenedItems.map((item) => ({ ...item, [childrenProp]: [] }))
let update: {
id: UniqueIdentifier | null
parentId: UniqueIdentifier | null
index: number
} = {
id: null,
parentId: null,
index: 0,
}
items.forEach((item, index) => {
const {
id,
index: _index,
depth: _depth,
parentId: _parentId,
...rest
} = item
const children = (item[childrenProp] || []) as T[]
const parentId = _parentId ?? root.id
const parent = nodes[parentId] ?? findItem(items, parentId)
nodes[id] = { id, [childrenProp]: children } as T
;(parent[childrenProp] as T[]).push({
id,
...rest,
[childrenProp]: children,
} as T)
/**
* Get the information for them item that was moved to the `newIndex`.
*/
if (index === newIndex) {
const parentChildren = parent[childrenProp] as FlattenedItem[]
update = {
id: item.id,
parentId: parent.id === "root" ? null : parent.id,
index: parentChildren.length - 1,
}
}
})
if (!update.id) {
throw new Error("Could not find item")
}
return {
items: root[childrenProp] as T[],
update: update as ItemUpdate,
}
}
export function findItem<T extends TreeItem>(
items: T[],
itemId: UniqueIdentifier
) {
return items.find(({ id }) => id === itemId)
}
export function findItemDeep<T extends TreeItem>(
items: T[],
itemId: UniqueIdentifier,
childrenProp: string
): TreeItem | undefined {
for (const item of items) {
const { id } = item
const children = (item[childrenProp] || []) as T[]
if (id === itemId) {
return item
}
if (children.length) {
const child = findItemDeep(children, itemId, childrenProp)
if (child) {
return child
}
}
}
return undefined
}
export function setProperty<TItem extends TreeItem, T extends keyof TItem>(
items: TItem[],
id: UniqueIdentifier,
property: T,
childrenProp: keyof TItem, // Make childrenProp a key of TItem
setter: (value: TItem[T]) => TItem[T]
): TItem[] {
return items.map((item) => {
if (item.id === id) {
return {
...item,
[property]: setter(item[property]),
}
}
const children = item[childrenProp] as TItem[] | undefined
if (children && children.length) {
return {
...item,
[childrenProp]: setProperty(
children,
id,
property,
childrenProp,
setter
),
} as TItem // Explicitly cast to TItem
}
return item
})
}
function countChildren<T extends TreeItem>(
items: T[],
count = 0,
childrenProp: string
): number {
return items.reduce((acc, item) => {
const children = (item[childrenProp] || []) as T[]
if (children.length) {
return countChildren(children, acc + 1, childrenProp)
}
return acc + 1
}, count)
}
export function getChildCount<T extends TreeItem>(
items: T[],
id: UniqueIdentifier,
childrenProp: string
) {
const item = findItemDeep(items, id, childrenProp)
const children = (item?.[childrenProp] || []) as T[]
return item ? countChildren(children, 0, childrenProp) : 0
}
export function removeChildrenOf(
items: FlattenedItem[],
ids: UniqueIdentifier[],
childrenProp: string
) {
const excludeParentIds = [...ids]
return items.filter((item) => {
if (item.parentId && excludeParentIds.includes(item.parentId)) {
const children = (item[childrenProp] || []) as FlattenedItem[]
if (children.length) {
excludeParentIds.push(item.id)
}
return false
}
return true
})
}
export function listItemsWithChildren<T extends TreeItem>(
items: T[],
childrenProp: string
): T[] {
return items.map((item) => {
return {
...item,
[childrenProp]: item[childrenProp]
? listItemsWithChildren(item[childrenProp] as TreeItem[], childrenProp)
: [],
}
})
}