@sanity/hierarchical-document-list 2.1.3 → 3.0.0

package/src/utils/throwError.ts

@@ -1,9 +0,0 @@
-const ERROR_MESSAGES = {
-  invalidDocumentId: 'Please add a documentId to your tree',
-  invalidDocumentType: 'Please add a valid documentType to createHierarchicalSchemas',
-  invalidReferenceTo: "Missing valid 'referenceTo' value",
-}
-
-export default function throwError(message: keyof typeof ERROR_MESSAGES, extraContext = ''): void {
-  throw new Error(`[hierarchical input] ${ERROR_MESSAGES[message]} ${extraContext}`)
-}

package/src/utils/treeData.tsx

@@ -1,119 +0,0 @@
-import {TreeItem} from '@nosferatu500/react-sortable-tree'
-import {randomKey} from '@sanity/util/content'
-import {SanityDocument} from 'sanity'
-import DocumentInNode from '../components/DocumentInNode'
-import NodeActions from '../components/NodeActions'
-import {
-  AllItems,
-  DocumentPair,
-  EnhancedTreeItem,
-  LocalTreeItem,
-  NodeProps,
-  StoredTreeItem,
-  VisibilityMap
-} from '../types'
-import flatDataToTree from './flatDataToTree'
-import {INTERNAL_NODE_TYPE, INTERNAL_NODE_VALUE_TYPE} from './injectNodeTypeInPatches'
-
-export const dataToEditorTree = ({
-  tree,
-  allItems,
-  visibilityMap
-}: {
-  tree: StoredTreeItem[]
-  allItems: AllItems
-  visibilityMap: VisibilityMap
-}): LocalTreeItem[] => {
-  const itemsWithTitle = tree
-    .filter((item) => item?.value?.reference?._ref)
-    .map((item) => {
-      const refId = item.value?.reference?._ref
-      const docPair = refId ? allItems[refId] : undefined
-      const draftDoc = docPair?.draft
-      const publishedDoc = docPair?.published
-
-      const enhancedItem: LocalTreeItem = {
-        ...item,
-        expanded: visibilityMap[item._key] !== false,
-        draftId: draftDoc?._id,
-        publishedId: publishedDoc?._id,
-        draftUpdatedAt: draftDoc?._updatedAt,
-        publishedUpdatedAt: publishedDoc?._updatedAt
-      }
-
-      return {
-        ...enhancedItem,
-        title: (nodeProps: NodeProps) => (
-          <DocumentInNode item={enhancedItem} action={<NodeActions nodeProps={nodeProps} />} />
-        ),
-        children: []
-      }
-    })
-  return flatDataToTree(itemsWithTitle)
-}
-
-const documentPairToNode = (doc?: DocumentPair): EnhancedTreeItem | undefined => {
-  if (!doc?.published?._id) {
-    return undefined
-  }
-
-  return {
-    _key: randomKey(12),
-    _type: INTERNAL_NODE_TYPE,
-    draftId: doc.draft?._id,
-    draftUpdatedAt: doc.draft?._updatedAt,
-    publishedId: doc.published._id,
-    publishedUpdatedAt: doc.published?._updatedAt,
-    value: {
-      _type: INTERNAL_NODE_VALUE_TYPE,
-      reference: {
-        _ref: doc.published._id,
-        _type: 'reference',
-        _weak: true
-      },
-      docType: doc.published._type
-    }
-  }
-}
-
-export const flatTree = (tree: TreeItem[]): TreeItem[] => {
-  return tree.reduce((flattened, item) => {
-    const {children, ...node} = item
-    return [...flattened, node, ...(Array.isArray(children) ? flatTree(children) : [])]
-  }, [] as TreeItem[])
-}
-
-export interface FetchData {
-  mainTree?: LocalTreeItem[]
-  allItems?: SanityDocument[]
-}
-
-export const getUnaddedItems = (data: {
-  allItems: AllItems
-  tree: StoredTreeItem[]
-}): EnhancedTreeItem[] => {
-  if (!data.tree) {
-    return Object.entries(data.allItems)
-      .map((value) => documentPairToNode(value[1]))
-      .filter(Boolean) as EnhancedTreeItem[]
-  }
-
-  return Object.entries(data.allItems)
-    .filter(
-      ([publishedId]) =>
-        publishedId &&
-        // unadded items shouldn't be in the tree
-        !data.tree.some((treeItem) => treeItem?.value?.reference?._ref === publishedId)
-    )
-    .map(([, documentPair]) => documentPairToNode(documentPair))
-    .filter(Boolean) as EnhancedTreeItem[]
-}
-
-export function normalizeNodeForStorage(item: LocalTreeItem): StoredTreeItem {
-  return {
-    _key: item._key,
-    _type: item._type || INTERNAL_NODE_TYPE,
-    value: item.value,
-    parent: item.parent
-  }
-}

package/src/utils/treePatches.ts

@@ -1,171 +0,0 @@
-import {
-  FlatDataItem,
-  FullTree,
-  getFlatDataFromTree,
-  NodeData,
-  TreeItem
-} from '@nosferatu500/react-sortable-tree'
-import {randomKey} from '@sanity/util/content'
-import * as Patch from 'sanity'
-import {LocalTreeItem, NodeProps} from '../types'
-import getAdjescentNodes from './getAdjescentNodes'
-import moveItemInArray from './moveItemInArray'
-import {normalizeNodeForStorage} from './treeData'
-
-export type HandleMovedNodeData = Omit<
-  NodeData & FullTree & any,
-  'prevPath' | 'prevTreeIndex' | 'path' | 'treeIndex' | 'node'
-> & {node: LocalTreeItem}
-
-export type HandleMovedNode = (moveData: HandleMovedNodeData) => void
-
-export function getAddItemPatch(item: LocalTreeItem): unknown[] {
-  const normalizedNode = normalizeNodeForStorage(item)
-
-  return [
-    // Add the node to the end of the tree
-    Patch.insert([normalizedNode], 'after', [-1])
-  ]
-}
-
-export function getDuplicateItemPatch(nodeProps: NodeProps): unknown[] {
-  const newItem = {
-    ...nodeProps.node,
-    _key: randomKey(12)
-  }
-  const normalizedNode = normalizeNodeForStorage(newItem)
-
-  return [
-    // Add duplicated node before the existing one
-    Patch.insert([normalizedNode], 'before', [{_key: nodeProps.node._key}])
-  ]
-}
-
-export function getRemoveItemPatch({node}: Pick<NodeProps, 'node'>): unknown[] {
-  const keyPath = {_key: node._key}
-  const children = getChildrenPaths(node)
-
-  return [
-    // 1. Unset the removed node
-    Patch.unset([keyPath]),
-
-    // 2. Unset its children
-    ...children.map((path) => Patch.unset([{_key: path}]))
-  ]
-}
-
-export function getMovedNodePatch(data: HandleMovedNodeData): unknown[] {
-  const {nextParentNode} = data
-  const keyPath = {_key: data.node._key}
-
-  // === REMOVING NODE FROM TREE ===
-  // `nextPath` will be null if the item is removed from tree
-  if (!Array.isArray(data.nextPath)) {
-    return getRemoveItemPatch({node: data.node})
-  }
-
-  const nextFlatTree = getFlatDataFromTree({
-    treeData: data.treeData,
-    getNodeKey: (t) => t.node._key
-  })
-  const normalizedNode = normalizeNodeForStorage(data.node)
-
-  const {leadingNode, followingNode} = getAdjescentNodes({
-    flatTree: nextFlatTree,
-    node: data.node,
-    treeIndex: data.nextTreeIndex
-  })
-
-  return [
-    // 1. Unset the moved node
-    // (will be ignored by Content Lake on new nodes with _key not yet in tree)
-    Patch.unset([keyPath]),
-
-    // 2. SIBLING-BASED PLACEMENT
-    // If we were to place solely based on nextTreeIndex, concurrent changes from other editors could put the new node in an unexpected position.
-    // Let's instead anchor it to the _key of the sibling coming before or after it.
-    leadingNode?.node?._key
-      ? // After the sibling before it
-        Patch.insert([normalizedNode], 'after', [{_key: leadingNode.node._key}])
-      : // Or before the sibling right after it, in case there's no leading sibling node
-        // prettier-ignore
-        Patch.insert([normalizedNode], 'before', [followingNode?.node?._key ? {_key: followingNode.node._key} : data.nextTreeIndex]),
-
-    // 3. Patch the new node with its new `parent`
-    nextParentNode
-      ? // If it has a parent node, set that parent's _key
-        Patch.set(nextParentNode._key, [keyPath, 'parent'])
-      : // Else remove the parent key entirely
-        Patch.unset([keyPath, 'parent'])
-  ]
-}
-
-function getChildrenPaths(node: TreeItem): string[] {
-  if (!Array.isArray(node.children)) {
-    return []
-  }
-
-  return node.children
-    .reduce(
-      (keyPaths, child) => [...keyPaths, child._key, ...getChildrenPaths(child)],
-      [] as string[]
-    )
-    .filter(Boolean)
-}
-
-export function getMoveItemPatch({
-  nodeProps: {node, treeIndex},
-  localTree,
-  direction = 'up'
-}: {
-  nodeProps: any
-  localTree: TreeItem[]
-  direction: 'up' | 'down'
-}): unknown[] {
-  const keyPath = {_key: node._key}
-
-  const nextTreeIndex = treeIndex + (direction === 'up' ? -1 : 1)
-
-  const flatTree = getFlatDataFromTree({
-    treeData: localTree,
-    getNodeKey: (t) => t.node._key
-  })
-  const nextFlatTree = moveItemInArray<FlatDataItem>({
-    array: flatTree,
-    fromIndex: treeIndex,
-    toIndex: nextTreeIndex
-  })
-  const {leadingNode, followingNode} = getAdjescentNodes({
-    flatTree: nextFlatTree,
-    node,
-    treeIndex: nextTreeIndex
-  })
-
-  const normalizedNode = normalizeNodeForStorage(node)
-
-  // When moving up, look at following node to figure out what is the next parent.
-  const nodeToInheritParent = direction === 'up' ? followingNode : leadingNode
-  const nextParentNode = nodeToInheritParent?.parentNode
-
-  return [
-    // 1. Unset the moved node
-    // (will be ignored by Content Lake on new nodes with _key not yet in tree)
-    Patch.unset([keyPath]),
-
-    // 2. SIBLING-BASED PLACEMENT
-    leadingNode?.node?._key
-      ? // After the sibling before it
-        Patch.insert([normalizedNode], 'after', [{_key: leadingNode.node._key}])
-      : // Or before the sibling right after it, in case there's no leading sibling node
-        Patch.insert([normalizedNode], 'before', [
-          followingNode?.node?._key ? {_key: followingNode.node._key} : nextTreeIndex
-        ]),
-
-    // 3. Patch the new node with its new `parent`
-    nextParentNode
-      ? // If it has a parent node, set that parent's _key
-        Patch.set(nextParentNode._key, [keyPath, 'parent'])
-      : // Else remove the parent key entirely
-        Patch.unset([keyPath, 'parent'])
-  ]
-}

package/v2-incompatible.js

@@ -1,11 +0,0 @@
-const {showIncompatiblePluginDialog} = require('@sanity/incompatible-plugin')
-const {name, version, sanityExchangeUrl} = require('./package.json')
-
-export default showIncompatiblePluginDialog({
-  name: name,
-  versions: {
-    v3: version,
-    v2: undefined,
-  },
-  sanityExchangeUrl,
-})