@sanity/sdk-react 0.0.0-alpha.8 → 0.0.0-chore-react-18-compat.0

package/src/hooks/document/useDocumentEvent.test.ts

@@ -0,0 +1,63 @@
+// tests/useDocumentEvent.test.ts
+import {
+  createSanityInstance,
+  type DocumentEvent,
+  type DocumentHandle,
+  subscribeDocumentEvents,
+} from '@sanity/sdk'
+import {renderHook} from '@testing-library/react'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+import {useDocumentEvent} from './useDocumentEvent'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...original, subscribeDocumentEvents: vi.fn()}
+})
+
+vi.mock('../context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn(),
+}))
+
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+const docHandle: DocumentHandle = {
+  _id: 'doc1',
+  _type: 'book',
+  resourceId: 'document:p.d:doc1',
+}
+
+describe('useDocumentEvent hook', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.mocked(useSanityInstance).mockReturnValue(instance)
+  })
+
+  it('calls subscribeDocumentEvents with instance and a stable handler', () => {
+    const handler = vi.fn()
+    const unsubscribe = vi.fn()
+    vi.mocked(subscribeDocumentEvents).mockReturnValue(unsubscribe)
+
+    renderHook(() => useDocumentEvent(handler, docHandle))
+
+    expect(vi.mocked(subscribeDocumentEvents)).toHaveBeenCalledTimes(1)
+    expect(vi.mocked(subscribeDocumentEvents).mock.calls[0][0]).toBe(instance)
+
+    const stableHandler = vi.mocked(subscribeDocumentEvents).mock.calls[0][1]
+    expect(typeof stableHandler).toBe('function')
+
+    const event = {type: 'edited', documentId: 'doc1', outgoing: {}} as DocumentEvent
+    stableHandler(event)
+    expect(handler).toHaveBeenCalledWith(event)
+  })
+
+  it('calls the unsubscribe function on unmount', () => {
+    const handler = vi.fn()
+    const unsubscribe = vi.fn()
+    vi.mocked(subscribeDocumentEvents).mockReturnValue(unsubscribe)
+
+    const {unmount} = renderHook(() => useDocumentEvent(handler, docHandle))
+    unmount()
+    expect(unsubscribe).toHaveBeenCalledTimes(1)
+  })
+})

package/src/hooks/document/useDocumentEvent.ts

@@ -0,0 +1,54 @@
+import {
+  type DocumentEvent,
+  type DocumentHandle,
+  getResourceId,
+  subscribeDocumentEvents,
+} from '@sanity/sdk'
+import {useCallback, useEffect, useInsertionEffect, useRef} from 'react'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+
+/**
+ *
+ * @beta
+ *
+ * Subscribes an event handler to events in your application’s document store, such as document
+ * creation, deletion, and updates.
+ *
+ * @category Documents
+ * @param handler - The event handler to register.
+ * @param doc - The document to subscribe to events for. If you pass a `DocumentHandle` with a `resourceId` (in the format of `document:projectId.dataset:documentId`)
+ * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `resourceId` is provided, the default project and dataset from your `SanityApp` configuration will be used.
+ * @example
+ * ```
+ * import {useDocumentEvent} from '@sanity/sdk-react'
+ * import {type DocumentEvent} from '@sanity/sdk'
+ *
+ * useDocumentEvent((event) => {
+ *   if (event.type === DocumentEvent.DocumentDeletedEvent) {
+ *     alert(`Document with ID ${event.documentId} deleted!`)
+ *   } else {
+ *     console.log(event)
+ *   }
+ * })
+ * ```
+ */
+export function useDocumentEvent(
+  handler: (documentEvent: DocumentEvent) => void,
+  doc: DocumentHandle,
+): void {
+  const ref = useRef(handler)
+
+  useInsertionEffect(() => {
+    ref.current = handler
+  })
+
+  const stableHandler = useCallback((documentEvent: DocumentEvent) => {
+    return ref.current(documentEvent)
+  }, [])
+
+  const instance = useSanityInstance(getResourceId(doc.resourceId))
+  useEffect(() => {
+    return subscribeDocumentEvents(instance, stableHandler)
+  }, [instance, stableHandler])
+}

package/src/hooks/document/useDocumentPermissions.ts

@@ -0,0 +1,84 @@
+import {
+  type DocumentAction,
+  type DocumentPermissionsResult,
+  getPermissionsState,
+  getResourceId,
+} from '@sanity/sdk'
+import {useCallback, useMemo, useSyncExternalStore} from 'react'
+import {filter, firstValueFrom} from 'rxjs'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+
+/**
+ *
+ * @beta
+ *
+ * Check if the current user has the specified permissions for the given document actions.
+ *
+ * @category Permissions
+ * @param actions - One more more calls to a particular document action function for a given document
+ * @returns An object that specifies whether the action is allowed; if the action is not allowed, an explanatory message and list of reasons is also provided.
+ *
+ * @example Checking for permission to publish a document
+ * ```ts
+ * import {useDocumentPermissions, useApplyDocumentActions} from '@sanity/sdk-react'
+ * import {publishDocument} from '@sanity/sdk'
+ *
+ * export function PublishButton({doc}: {doc: DocumentHandle}) {
+ *   const publishPermissions = useDocumentPermissions(publishDocument(doc))
+ *   const applyAction = useApplyDocumentActions()
+ *
+ *   return (
+ *     <>
+ *       <button
+ *         disabled={!publishPermissions.allowed}
+ *         onClick={() => applyAction(publishDocument(doc))}
+ *         popoverTarget={`${publishPermissions.allowed ? undefined : 'publishButtonPopover'}`}
+ *       >
+ *         Publish
+ *       </button>
+ *       {!publishPermissions.allowed && (
+ *         <div popover id="publishButtonPopover">
+ *           {publishPermissions.message}
+ *         </div>
+ *       )}
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export function useDocumentPermissions(
+  actions: DocumentAction | DocumentAction[],
+): DocumentPermissionsResult {
+  // if actions is an array, we need to check each action to see if the resourceId is the same
+  if (Array.isArray(actions)) {
+    const resourceIds = actions.map((action) => action.resourceId)
+    const uniqueResourceIds = new Set(resourceIds)
+    if (uniqueResourceIds.size !== 1) {
+      throw new Error('All actions must have the same resourceId')
+    }
+  }
+  const resourceId = Array.isArray(actions)
+    ? getResourceId(actions[0].resourceId)
+    : getResourceId(actions.resourceId)
+
+  const instance = useSanityInstance(resourceId)
+  const isDocumentReady = useCallback(
+    () => getPermissionsState(instance, actions).getCurrent() !== undefined,
+    [actions, instance],
+  )
+  if (!isDocumentReady()) {
+    throw firstValueFrom(
+      getPermissionsState(instance, actions).observable.pipe(
+        filter((result) => result !== undefined),
+      ),
+    )
+  }
+
+  const {subscribe, getCurrent} = useMemo(
+    () => getPermissionsState(instance, actions),
+    [actions, instance],
+  )
+
+  return useSyncExternalStore(subscribe, getCurrent) as DocumentPermissionsResult
+}

package/src/hooks/document/useDocumentSyncStatus.test.ts

@@ -0,0 +1,16 @@
+import {getDocumentSyncStatus} from '@sanity/sdk'
+import {identity} from 'rxjs'
+import {describe, it} from 'vitest'
+
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
+
+vi.mock('../helpers/createStateSourceHook', () => ({createStateSourceHook: vi.fn(identity)}))
+vi.mock('@sanity/sdk', () => ({getDocumentSyncStatus: vi.fn()}))
+
+describe('useDocumentSyncStatus', () => {
+  it('calls `createStateSourceHook` with `getTokenState`', async () => {
+    const {useDocumentSyncStatus} = await import('./useDocumentSyncStatus')
+    expect(createStateSourceHook).toHaveBeenCalledWith(getDocumentSyncStatus)
+    expect(useDocumentSyncStatus).toBe(getDocumentSyncStatus)
+  })
+})

package/src/hooks/document/useDocumentSyncStatus.ts

@@ -0,0 +1,33 @@
+import {type DocumentHandle, getDocumentSyncStatus} from '@sanity/sdk'
+
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
+
+type UseDocumentSyncStatus = {
+  /**
+   * Exposes the document’s sync status between local and remote document states.
+   *
+   * @category Documents
+   * @param doc - The document handle to get sync status for. If you pass a `DocumentHandle` with a `resourceId` (in the format of `document:projectId.dataset:documentId`)
+   * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `resourceId` is provided, the default project and dataset from your `SanityApp` configuration will be used.
+   * @returns `true` if local changes are synced with remote, `false` if the changes are not synced, and `undefined` if the document is not found
+   * @example Disable a Save button when there are no changes to sync
+   * ```
+   * const myDocumentHandle = { _id: 'documentId', _type: 'documentType', resourceId: 'document:projectId:dataset:documentId' }
+   * const documentSynced = useDocumentSyncStatus(myDocumentHandle)
+   *
+   * return (
+   *   <button disabled={documentSynced}>
+   *     Save Changes
+   *   </button>
+   * )
+   * ```
+   */
+  (doc: DocumentHandle): boolean | undefined
+}
+
+/**
+ * @beta
+ * @function
+ */
+export const useDocumentSyncStatus: UseDocumentSyncStatus =
+  createStateSourceHook(getDocumentSyncStatus)

package/src/hooks/document/useEditDocument.test.ts

@@ -0,0 +1,179 @@
+// tests/useEditDocument.test.ts
+import {
+  createSanityInstance,
+  type DocumentHandle,
+  editDocument,
+  getDocumentState,
+  resolveDocument,
+  type StateSource,
+} from '@sanity/sdk'
+import {type SanityDocument} from '@sanity/types'
+import {renderHook} from '@testing-library/react'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+import {useApplyDocumentActions} from './useApplyDocumentActions'
+import {useEditDocument} from './useEditDocument'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...original,
+    getDocumentState: vi.fn(),
+    resolveDocument: vi.fn(),
+    editDocument: vi.fn(original.editDocument),
+  }
+})
+
+vi.mock('../context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn(),
+}))
+
+vi.mock('./useApplyDocumentActions', () => ({
+  useApplyDocumentActions: vi.fn(),
+}))
+
+// Create a fake instance to be returned by useSanityInstance.
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+
+const doc = {
+  _id: 'doc1',
+  foo: 'bar',
+  _type: 'book',
+  _rev: 'tx0',
+  _createdAt: '2025-02-06T00:11:00.000Z',
+  _updatedAt: '2025-02-06T00:11:00.000Z',
+} satisfies SanityDocument
+
+const docHandle: DocumentHandle<SanityDocument> = {
+  _id: 'doc1',
+  _type: 'book',
+  resourceId: 'document:p.d:doc1',
+}
+
+describe('useEditDocument hook', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(useSanityInstance).mockReturnValue(instance)
+  })
+
+  it('applies a single edit action for the given path', async () => {
+    const getCurrent = vi.fn().mockReturnValue(doc)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const apply = vi.fn().mockResolvedValue({transactionId: 'tx1'})
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
+
+    const {result} = renderHook(() => useEditDocument(docHandle, 'foo'))
+    const promise = result.current('newValue')
+    expect(editDocument).toHaveBeenCalledWith(docHandle, {set: {foo: 'newValue'}})
+    expect(apply).toHaveBeenCalledWith(editDocument(docHandle, {set: {foo: 'newValue'}}))
+    const actionsResult = await promise
+    expect(actionsResult).toEqual({transactionId: 'tx1'})
+  })
+
+  it('applies edit actions for changed fields', async () => {
+    // Set up current document state.
+    const currentDoc = {...doc, foo: 'bar', extra: 'old'}
+    const getCurrent = vi.fn().mockReturnValue(currentDoc)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const apply = vi.fn().mockResolvedValue({transactionId: 'tx2'})
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
+
+    const {result} = renderHook(() => useEditDocument(docHandle))
+    const promise = result.current({...doc, foo: 'baz', extra: 'old', _id: 'doc1'})
+    expect(apply).toHaveBeenCalledWith([editDocument(docHandle, {set: {foo: 'baz'}})])
+    const actionsResult = await promise
+    expect(actionsResult).toEqual({transactionId: 'tx2'})
+  })
+
+  it('applies a single edit action using an updater function for the given path', async () => {
+    const getCurrent = vi.fn().mockReturnValue(doc.foo)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const apply = vi.fn().mockResolvedValue({transactionId: 'tx3'})
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
+
+    const {result} = renderHook(() => useEditDocument(docHandle, 'foo'))
+    const promise = result.current((prev: unknown) => `${prev}Updated`) // 'bar' becomes 'barUpdated'
+    expect(editDocument).toHaveBeenCalledWith(docHandle, {set: {foo: 'barUpdated'}})
+    expect(apply).toHaveBeenCalledWith(editDocument(docHandle, {set: {foo: 'barUpdated'}}))
+    const actionsResult = await promise
+    expect(actionsResult).toEqual({transactionId: 'tx3'})
+  })
+
+  it('applies edit actions using an updater function for the entire document', async () => {
+    const currentDoc = {...doc, foo: 'bar', extra: 'old'}
+    const getCurrent = vi.fn().mockReturnValue(currentDoc)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const apply = vi.fn().mockResolvedValue({transactionId: 'tx4'})
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
+
+    const {result} = renderHook(() => useEditDocument(docHandle))
+    const promise = result.current((prevDoc) => ({...prevDoc, foo: 'baz'}))
+    expect(apply).toHaveBeenCalledWith([editDocument(docHandle, {set: {foo: 'baz'}})])
+    const actionsResult = await promise
+    expect(actionsResult).toEqual({transactionId: 'tx4'})
+  })
+
+  it('throws an error if next value is not an object', () => {
+    const getCurrent = vi.fn().mockReturnValue(doc)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const fakeApply = vi.fn()
+    vi.mocked(useApplyDocumentActions).mockReturnValue(fakeApply)
+
+    const {result} = renderHook(() => useEditDocument(docHandle))
+    expect(() => result.current('notAnObject' as unknown as SanityDocument)).toThrowError(
+      'No path was provided to `useEditDocument` and the value provided was not a document object.',
+    )
+  })
+
+  it('throws a promise (suspends) when the document is not ready', () => {
+    const getCurrent = vi.fn().mockReturnValue(undefined)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<unknown>)
+
+    const resolveDocPromise = Promise.resolve(doc)
+
+    // Also, simulate resolveDocument to return a known promise.
+    vi.mocked(resolveDocument).mockReturnValue(resolveDocPromise)
+
+    // Render the hook and capture the thrown promise.
+    const {result} = renderHook(() => {
+      try {
+        return useEditDocument(docHandle)
+      } catch (e) {
+        return e
+      }
+    })
+
+    // When the document is not ready, the hook throws the promise from resolveDocument.
+    expect(result.current).toBe(resolveDocPromise)
+  })
+})

package/src/hooks/document/useEditDocument.ts

@@ -0,0 +1,195 @@
+import {
+  type ActionsResult,
+  type DocumentHandle,
+  editDocument,
+  getDocumentState,
+  getResourceId,
+  type JsonMatch,
+  type JsonMatchPath,
+  resolveDocument,
+} from '@sanity/sdk'
+import {type SanityDocument} from '@sanity/types'
+import {useCallback} from 'react'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+import {useApplyDocumentActions} from './useApplyDocumentActions'
+
+const ignoredKeys = ['_id', '_type', '_createdAt', '_updatedAt', '_rev']
+
+type Updater<TValue> = TValue | ((nextValue: TValue) => TValue)
+
+/**
+ *
+ * @beta
+ *
+ * ## useEditDocument(doc, path)
+ * Edit a nested value within a document
+ *
+ * @category Documents
+ * @param doc - The document to be edited; either as a document handle or the document’s ID a string
+ * @param path - The path to the nested value to be edited
+ * @returns A function to update the nested value. Accepts either a new value, or an updater function that exposes the previous value and returns a new value.
+ * @example Update a document’s name by providing the new value directly
+ * ```
+ * const handle = { _id: 'documentId', _type: 'documentType' }
+ * const name = useDocument(handle, 'name')
+ * const editName = useEditDocument(handle, 'name')
+ *
+ * function handleNameChange(event: React.ChangeEvent<HTMLInputElement>) {
+ *   editName(event.target.value)
+ * }
+ *
+ * return (
+ *   <input type='text' value={name} onChange={handleNameChange} />
+ * )
+ * ```
+ *
+ * @example Update a count on a document by providing an updater function
+ * ```
+ * const handle = { _id: 'documentId', _type: 'documentType' }
+ * const count = useDocument(handle, 'count')
+ * const editCount = useEditDocument(handle, 'count')
+ *
+ * function incrementCount() {
+ *   editCount(previousCount => previousCount + 1)
+ * }
+ *
+ * return (
+ *   <>
+ *     <button onClick={incrementCount}>
+ *       Increment
+ *     </button>
+ *     Current count: {count}
+ *   </>
+ * )
+ * ```
+ */
+export function useEditDocument<
+  TDocument extends SanityDocument,
+  TPath extends JsonMatchPath<TDocument>,
+>(
+  doc: DocumentHandle<TDocument>,
+  path: TPath,
+): (nextValue: Updater<JsonMatch<TDocument, TPath>>) => Promise<ActionsResult<TDocument>>
+
+/**
+ *
+ * @beta
+ *
+ * ## useEditDocument(doc)
+ * Edit an entire document
+ * @param doc - The document to be edited; either as a document handle or the document’s ID a string. If you pass a `DocumentHandle` with a `resourceId` (in the format of `document:projectId.dataset:documentId`)
+ * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `resourceId` is provided, the default project and dataset from your `SanityApp` configuration will be used.
+ * @returns A function to update the document state. Accepts either a new document state, or an updater function that exposes the previous document state and returns the new document state.
+ * @example
+ * ```
+ * const myDocumentHandle = { _id: 'documentId', _type: 'documentType' }
+ *
+ * const myDocument = useDocument(myDocumentHandle)
+ * const { title, price } = myDocument
+ *
+ * const editMyDocument = useEditDocument(myDocumentHandle)
+ *
+ * function handleFieldChange(e: React.ChangeEvent<HTMLInputElement>) {
+ *   const {name, value} = e.currentTarget
+ *   // Use an updater function to update the document state based on the previous state
+ *   editMyDocument(previousDocument => ({
+ *     ...previousDocument,
+ *     [name]: value
+ *   }))
+ * }
+ *
+ * function handleSaleChange(e: React.ChangeEvent<HTMLInputElement>) {
+ *   const { checked } = e.currentTarget
+ *   if (checked) {
+ *     // Use an updater function to add a new salePrice field;
+ *     // set it at a 20% discount off the normal price
+ *     editMyDocument(previousDocument => ({
+ *       ...previousDocument,
+ *       salePrice: previousDocument.price * 0.8,
+ *     }))
+ *   } else {
+ *     // Get the document state without the salePrice field
+ *     const { salePrice, ...rest } = myDocument
+ *     // Update the document state to remove the salePrice field
+ *     editMyDocument(rest)
+ *   }
+ * }
+ *
+ * return (
+ *   <>
+ *     <form onSubmit={e => e.preventDefault()}>
+ *       <input name='title' type='text' value={title} onChange={handleFieldChange} />
+ *       <input name='price' type='number' value={price} onChange={handleFieldChange} />
+ *       <input
+ *         name='salePrice'
+ *         type='checkbox'
+ *         checked={Object(myDocument).hasOwnProperty('salePrice')}
+ *         onChange={handleSaleChange}
+ *       />
+ *     </form>
+ *     <pre><code>
+ *       {JSON.stringify(myDocument, null, 2)}
+ *     </code></pre>
+ *   </>
+ * )
+ * ```
+ */
+export function useEditDocument<TDocument extends SanityDocument>(
+  doc: DocumentHandle<TDocument>,
+): (nextValue: Updater<TDocument>) => Promise<ActionsResult<TDocument>>
+
+/**
+ *
+ * @beta
+ *
+ * Enables editing of a document’s state.
+ * When called with a `path` argument, the hook will return a function for updating a nested value.
+ * When called without a `path` argument, the hook will return a function for updating the entire document.
+ */
+export function useEditDocument(
+  doc: DocumentHandle,
+  path?: string,
+): (updater: Updater<unknown>) => Promise<ActionsResult> {
+  const resourceId = getResourceId(doc.resourceId)!
+  const documentId = doc._id
+  const instance = useSanityInstance(resourceId)
+  const apply = useApplyDocumentActions(resourceId)
+  const isDocumentReady = useCallback(
+    () => getDocumentState(instance, documentId).getCurrent() !== undefined,
+    [instance, documentId],
+  )
+  if (!isDocumentReady()) throw resolveDocument(instance, documentId)
+
+  return (updater: Updater<unknown>) => {
+    if (path) {
+      const nextValue =
+        typeof updater === 'function'
+          ? updater(getDocumentState(instance, documentId, path).getCurrent())
+          : updater
+
+      return apply(editDocument(doc, {set: {[path]: nextValue}}))
+    }
+
+    const current = getDocumentState(instance, documentId).getCurrent()
+    const nextValue = typeof updater === 'function' ? updater(current) : updater
+
+    if (typeof nextValue !== 'object' || !nextValue) {
+      throw new Error(
+        `No path was provided to \`useEditDocument\` and the value provided was not a document object.`,
+      )
+    }
+
+    const allKeys = Object.keys({...current, ...nextValue})
+    const editActions = allKeys
+      .filter((key) => !ignoredKeys.includes(key))
+      .filter((key) => current?.[key] !== nextValue[key])
+      .map((key) =>
+        key in nextValue
+          ? editDocument(doc, {set: {[key]: nextValue[key]}})
+          : editDocument(doc, {unset: [key]}),
+      )
+
+    return apply(editActions)
+  }
+}