@sanity/orderable-document-list 1.5.1 → 2.0.0

package/src/helpers/reorderDocuments.ts

@@ -1,133 +0,0 @@
-import {LexoRank} from 'lexorank'
-import type {PatchOperations} from 'sanity'
-
-import type {SanityDocumentWithOrder} from '../types'
-import {ORDER_FIELD_NAME} from './constants'
-import {parseOrderRank} from './parseOrderRank'
-
-export interface MaifestArgs {
-  entities: SanityDocumentWithOrder[]
-  selectedItems: SanityDocumentWithOrder[]
-  isMovingUp: boolean
-  curIndex: number
-  nextIndex: number
-  prevIndex: number
-}
-
-export interface ReorderArgs {
-  entities: SanityDocumentWithOrder[]
-  selectedIds: string[]
-  source: any
-  destination: any
-}
-
-export interface ReorderReturn {
-  newOrder: SanityDocumentWithOrder[]
-  patches: [string, PatchOperations][]
-  message: any
-}
-
-function lexicographicalSort(a: SanityDocumentWithOrder, b: SanityDocumentWithOrder) {
-  if (!a[ORDER_FIELD_NAME] || !b[ORDER_FIELD_NAME]) {
-    return 0
-  } else if (a[ORDER_FIELD_NAME] < b[ORDER_FIELD_NAME]) {
-    return -1
-  } else if (a[ORDER_FIELD_NAME] > b[ORDER_FIELD_NAME]) {
-    return 1
-  }
-  return 0
-}
-
-export const reorderDocuments = ({
-  entities,
-  selectedIds,
-  source,
-  destination,
-}: ReorderArgs): ReorderReturn => {
-  const startIndex = source.index
-  const endIndex = destination.index
-  const isMovingUp = startIndex > endIndex
-  const selectedItems = entities.filter((item) => selectedIds.includes(item._id))
-  const message = [
-    'Moved',
-    selectedItems.length === 1 ? '1 document' : `${selectedItems.length} documents`,
-    isMovingUp ? 'up' : 'down',
-    'from position',
-    `${startIndex + 1} to ${endIndex + 1}`,
-  ].join(' ')
-
-  const {all, selected} = entities.reduce<{
-    all: SanityDocumentWithOrder[]
-    selected: SanityDocumentWithOrder[]
-  }>(
-    (acc, cur, curIndex) => {
-      // Selected items get spread in below, so skip them here
-      if (selectedIds.includes(cur._id)) {
-        return {all: acc.all, selected: acc.selected}
-      }
-
-      // Drop selected items in
-      if (curIndex === endIndex) {
-        const prevIndex = curIndex - 1
-        const prevRank = parseOrderRank(entities[prevIndex]?.[ORDER_FIELD_NAME], LexoRank.min())
-
-        const curRank = parseOrderRank(entities[curIndex][ORDER_FIELD_NAME], LexoRank.min())
-
-        const nextIndex = curIndex + 1
-        const nextRank = parseOrderRank(entities[nextIndex]?.[ORDER_FIELD_NAME], LexoRank.max())
-
-        let betweenRank = isMovingUp ? prevRank.between(curRank) : curRank.between(nextRank)
-
-        // For each selected item, assign a new orderRank between now and next
-        for (let selectedIndex = 0; selectedIndex < selectedItems.length; selectedIndex += 1) {
-          selectedItems[selectedIndex][ORDER_FIELD_NAME] = betweenRank.toString()
-          betweenRank = isMovingUp ? betweenRank.between(curRank) : betweenRank.between(nextRank)
-        }
-
-        return {
-          // The `all` array gets sorted by order field later anyway
-          // so that this probably isn't necessary ¯\_(ツ)_/¯
-          all: isMovingUp
-            ? [...acc.all, ...selectedItems, cur]
-            : [...acc.all, cur, ...selectedItems],
-          selected: selectedItems,
-        }
-      }
-
-      return {all: [...acc.all, cur], selected: acc.selected}
-    },
-    {all: [], selected: []},
-  )
-
-  const patches = selected.flatMap((doc) => {
-    const docPatches: [string, PatchOperations][] = [
-      [
-        doc._id,
-        {
-          set: {
-            [ORDER_FIELD_NAME]: doc[ORDER_FIELD_NAME],
-          },
-        },
-      ],
-    ]
-
-    // If it's a draft, we need to patch the published document as well
-    if (doc._id.startsWith('drafts.') && doc.hasPublished) {
-      docPatches.push([
-        doc._id.replace('drafts.', ''),
-        {
-          set: {
-            [ORDER_FIELD_NAME]: doc[ORDER_FIELD_NAME],
-          },
-        },
-      ])
-    }
-
-    return docPatches
-  })
-
-  // Safety-check to make sure everything is in order
-  const allSorted = all.sort(lexicographicalSort)
-
-  return {newOrder: allSorted, patches, message}
-}

package/src/helpers/resetOrder.ts

@@ -1,48 +0,0 @@
-import {LexoRank} from 'lexorank'
-import type {MultipleMutationResult, SanityClient} from '@sanity/client'
-import {ORDER_FIELD_NAME} from './constants'
-import {DocumentListQueryProps, getDocumentQuery} from './query'
-
-export interface ResetOrderParams extends DocumentListQueryProps {
-  client: SanityClient
-  currentVersion?: string
-}
-
-// Function to wipe and re-do ordering with LexoRank
-// Will at least attempt to start with the current order
-export async function resetOrder(params: ResetOrderParams): Promise<MultipleMutationResult | null> {
-  const {client, currentVersion, ...queryProps} = params
-  const {query, queryParams} = getDocumentQuery({...queryProps, currentVersion})
-
-  const documents = await client.fetch<
-    Array<{
-      _id: string
-      _type: string
-      [ORDER_FIELD_NAME]: string
-    }>
-  >(query, queryParams, {
-    tag: 'orderable-document-list.reset-order',
-  })
-
-  if (documents.length === 0) {
-    return null
-  }
-
-  let aLexoRank = LexoRank.min()
-
-  const transaction = documents
-    .map((doc) => doc._id)
-    .reduce((trx, documentId) => {
-      // Generate next rank before even the first document so there's room to move!
-      aLexoRank = aLexoRank.genNext().genNext()
-
-      return trx.patch(documentId, {
-        set: {[ORDER_FIELD_NAME]: aLexoRank.toString()},
-      })
-    }, client.transaction())
-
-  return transaction.commit({
-    visibility: 'async',
-    tag: 'orderable-document-list.reset-order',
-  })
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export {orderRankField, type RankFieldConfig} from './fields/orderRankField'
-export {orderRankOrdering} from './fields/orderRankOrdering'
-export {
-  orderableDocumentListDeskItem,
-  type OrderableListConfig,
-} from './desk-structure/orderableDocumentListDeskItem'
-export {OrderableDocumentList} from './OrderableDocumentList'

package/src/types.ts

@@ -1,10 +0,0 @@
-import type {SanityDocument} from 'sanity'
-
-import {ORDER_FIELD_NAME} from './helpers/constants'
-
-export interface SanityDocumentWithOrder extends SanityDocument {
-  [ORDER_FIELD_NAME]?: string
-  hasPublished?: boolean
-}
-
-export type NewItemPosition = 'after' | 'before'

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,
-})