@portabletext/editor 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -45,10 +45,6 @@
     "src"
   ],
   "dependencies": {
-    "@sanity/block-tools": "^3.47.0",
-    "@sanity/schema": "^3.47.0",
-    "@sanity/types": "^3.47.0",
-    "@sanity/util": "^3.47.0",
     "debug": "^3.2.7",
     "is-hotkey-esm": "^1.0.0",
     "lodash": "^4.17.21",
@@ -58,28 +54,46 @@
   "devDependencies": {
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@jest/globals": "^29.7.0",
-    "@playwright/test": "1.41.2",
+    "@playwright/test": "1.45.0",
     "@portabletext/toolkit": "^2.0.15",
+    "@sanity/block-tools": "^3.47.1",
     "@sanity/diff-match-patch": "^3.1.1",
+    "@sanity/eslint-config-i18n": "^1.1.0",
+    "@sanity/eslint-config-studio": "^4.0.0",
     "@sanity/pkg-utils": "^6.10.0",
+    "@sanity/schema": "^3.47.1",
     "@sanity/test": "0.0.1-alpha.1",
-    "@sanity/ui": "^2.4.0",
+    "@sanity/types": "^3.47.1",
+    "@sanity/ui": "^2.5.0",
+    "@sanity/util": "^3.47.1",
     "@testing-library/react": "^13.4.0",
     "@types/debug": "^4.1.5",
     "@types/express": "^4.17.21",
-    "@types/express-ws": "^3.0.1",
-    "@types/lodash": "^4.14.149",
+    "@types/express-ws": "^3.0.4",
+    "@types/lodash": "^4.17.5",
     "@types/node": "^18.19.8",
-    "@types/node-ipc": "^9.2.0",
+    "@types/node-ipc": "^9.2.3",
     "@types/react": "^18.3.3",
     "@types/react-dom": "^18.3.0",
-    "@types/ws": "~8.5.3",
+    "@types/ws": "~8.5.10",
+    "@typescript-eslint/eslint-plugin": "^7.14.1",
+    "@typescript-eslint/parser": "^7.14.1",
     "@vitejs/plugin-react": "^4.3.1",
     "dotenv": "^16.4.5",
-    "express": "^4.18.3",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-sanity": "^7.1.2",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-react-compiler": "0.0.0-experimental-51a85ea-20240601",
+    "eslint-plugin-tsdoc": "^0.3.0",
+    "eslint-plugin-unicorn": "^54.0.0",
+    "eslint-plugin-unused-imports": "^4.0.0",
+    "express": "^4.19.2",
     "express-ws": "^5.0.2",
     "jest": "^29.7.0",
-    "jest-dev-server": "^9.0.1",
+    "jest-dev-server": "^9.0.2",
     "jest-environment-jsdom": "^29.7.0",
     "jest-environment-node": "^29.7.0",
     "node-ipc": "npm:@node-ipc/compat@9.2.5",
@@ -88,13 +102,16 @@
     "rimraf": "^3.0.2",
     "rxjs": "^7.8.1",
     "styled-components": "^6.1.11",
-    "tsx": "^4.10.3",
+    "tsx": "^4.15.7",
     "typescript": "^5.4.5",
     "vite": "^4.5.3",
-    "@repo/tsconfig": "^0.0.0",
-    "@repo/package.config": "^0.0.0"
+    "@portabletext/patches": "^0.0.0"
   },
   "peerDependencies": {
+    "@sanity/block-tools": "^3.47.1",
+    "@sanity/schema": "^3.47.1",
+    "@sanity/types": "^3.47.1",
+    "@sanity/util": "^3.47.1",
     "react": "^16.9 || ^17 || ^18",
     "rxjs": "^7",
     "styled-components": "^6.1"
@@ -107,13 +124,14 @@
   },
   "scripts": {
     "build": "pkg-utils build --strict --check --clean",
+    "check:lint": "eslint .",
     "check:types": "tsc --project tsconfig.lib.json",
     "clean": "rimraf lib",
-    "dev": "cd ./e2e-tests/ && tsx serve",
-    "lint": "eslint .",
+    "dev": "pkg-utils watch",
+    "dev:e2e-server": "cd ./e2e-tests/ && tsx serve",
+    "lint:fix": "eslint . --fix",
     "test": "jest",
     "test:e2e": "jest --config=e2e-tests/e2e.config.cjs",
-    "test:watch": "jest --watch",
-    "watch": "pkg-utils watch"
+    "test:watch": "jest --watch"
   }
 }

package/src/editor/Editable.tsx

@@ -9,7 +9,6 @@ import {
   type HTMLProps,
   type KeyboardEvent,
   type MutableRefObject,
-  type ReactNode,
   type TextareaHTMLAttributes,
   useCallback,
   useEffect,
@@ -42,13 +41,13 @@ import {
   type EditorSelection,
   type OnCopyFn,
   type OnPasteFn,
-  type OnPasteResult,
   type RangeDecoration,
   type RenderAnnotationFunction,
   type RenderBlockFunction,
   type RenderChildFunction,
   type RenderDecoratorFunction,
   type RenderListItemFunction,
+  type RenderPlaceholderFunction,
   type RenderStyleFunction,
   type ScrollSelectionIntoViewFunction,
 } from '../types/editor'
@@ -100,7 +99,7 @@ export type PortableTextEditableProps = Omit<
   renderChild?: RenderChildFunction
   renderDecorator?: RenderDecoratorFunction
   renderListItem?: RenderListItemFunction
-  renderPlaceholder?: () => ReactNode
+  renderPlaceholder?: RenderPlaceholderFunction
   renderStyle?: RenderStyleFunction
   scrollSelectionIntoView?: ScrollSelectionIntoViewFunction
   selection?: EditorSelection
@@ -390,42 +389,37 @@ export const PortableTextEditable = forwardRef(function PortableTextEditable(
         slateEditor.insertData(event.clipboardData)
         return
       }
-      // Resolve it as promise (can be either async promise or sync return value)
-      new Promise<OnPasteResult>((resolve) => {
-        const value = PortableTextEditor.getValue(portableTextEditor)
-        const ptRange = toPortableTextRange(value, slateEditor.selection, schemaTypes)
-        const path = ptRange?.focus.path || []
-        resolve(
-          onPaste({
-            event,
-            value,
-            path,
-            schemaTypes,
-          }),
-        )
-      })
-        .then((result) => {
-          debug('Custom paste function from client resolved', result)
-          change$.next({type: 'loading', isLoading: true})
-          if (!result || !result.insert) {
-            debug('No result from custom paste handler, pasting normally')
-            slateEditor.insertData(event.clipboardData)
-            return
-          }
-          if (result && result.insert) {
-            slateEditor.insertFragment(
-              toSlateValue(result.insert as PortableTextBlock[], {schemaTypes}),
-            )
+
+      const value = PortableTextEditor.getValue(portableTextEditor)
+      const ptRange = toPortableTextRange(value, slateEditor.selection, schemaTypes)
+      const path = ptRange?.focus.path || []
+      const onPasteResult = onPaste({event, value, path, schemaTypes})
+
+      if (onPasteResult === undefined) {
+        debug('No result from custom paste handler, pasting normally')
+        slateEditor.insertData(event.clipboardData)
+      } else {
+        // Resolve it as promise (can be either async promise or sync return value)
+        change$.next({type: 'loading', isLoading: true})
+        Promise.resolve(onPasteResult)
+          .then((result) => {
+            debug('Custom paste function from client resolved', result)
+            if (result && result.insert) {
+              slateEditor.insertFragment(
+                toSlateValue(result.insert as PortableTextBlock[], {schemaTypes}),
+              )
+            } else {
+              console.warn('Your onPaste function returned something unexpected:', result)
+            }
+          })
+          .catch((error) => {
+            console.error(error) // eslint-disable-line no-console
+            return error
+          })
+          .finally(() => {
             change$.next({type: 'loading', isLoading: false})
-            return
-          }
-          console.warn('Your onPaste function returned something unexpected:', result)
-        })
-        .catch((error) => {
-          change$.next({type: 'loading', isLoading: false})
-          console.error(error) // eslint-disable-line no-console
-          return error
-        })
+          })
+      }
     },
     [change$, onPaste, portableTextEditor, schemaTypes, slateEditor],
   )

package/src/editor/components/Synchronizer.tsx

@@ -1,3 +1,4 @@
+import {type Patch} from '@portabletext/patches/types'
 import {type PortableTextBlock} from '@sanity/types'
 import {throttle} from 'lodash'
 import {
@@ -13,7 +14,6 @@ import {Editor} from 'slate'
 import {useSlate} from 'slate-react'
 
 import {type EditorChange, type EditorChanges, type EditorSelection} from '../../types/editor'
-import {type Patch} from '../../types/patch'
 import {debugWithName} from '../../utils/debug'
 import {IS_PROCESSING_LOCAL_CHANGES} from '../../utils/weakMaps'
 import {PortableTextEditorContext} from '../hooks/usePortableTextEditor'

package/src/editor/plugins/__tests__/createWithInsertData.test.tsx

@@ -0,0 +1,166 @@
+import {describe, expect, it} from '@jest/globals'
+import {isPortableTextSpan, isPortableTextTextBlock} from '@sanity/types'
+import {type Descendant} from 'slate'
+
+import {exportedForTesting} from '../createWithInsertData'
+
+const initialValue = [
+  {
+    _key: 'a',
+    _type: 'myTestBlockType',
+    children: [
+      {
+        _key: 'a1',
+        _type: 'span',
+        marks: ['link1'],
+        text: 'Block A',
+      },
+      {
+        _key: 'a2',
+        _type: 'span',
+        marks: ['colour1'],
+        text: 'Block B',
+      },
+    ],
+    markDefs: [
+      {
+        _key: 'link1',
+        _type: 'link',
+        href: 'google.com',
+        newTab: false,
+      },
+      {
+        _key: 'colour1',
+        _type: 'color',
+        color: 'red',
+      },
+    ],
+    style: 'normal',
+  },
+] satisfies Array<Descendant>
+
+describe('plugin: createWithInsertData _regenerateKeys', () => {
+  it('has MarkDefs that are allowed annotations', async () => {
+    const {_regenerateKeys} = exportedForTesting
+    let keyCursor = 0
+
+    const generatedValue = _regenerateKeys(
+      {
+        isTextBlock: isPortableTextTextBlock,
+        isTextSpan: isPortableTextSpan,
+      },
+      initialValue,
+      () => {
+        keyCursor++
+        return `k${keyCursor}`
+      },
+      'span',
+      {
+        annotations: [
+          // eslint-disable-next-line camelcase
+          {name: 'color', jsonType: 'object', fields: [], __experimental_search: []},
+          // eslint-disable-next-line camelcase
+          {name: 'link', jsonType: 'object', fields: [], __experimental_search: []},
+        ],
+      },
+    )
+
+    // the keys are not important here as it's not what we are testing here
+    expect(generatedValue).toStrictEqual([
+      {
+        _key: 'k3',
+        _type: 'myTestBlockType',
+        children: [
+          {_key: 'k4', _type: 'span', marks: ['k1'], text: 'Block A'},
+          {
+            _key: 'k5',
+            _type: 'span',
+            marks: ['k2'],
+            text: 'Block B',
+          },
+        ],
+        markDefs: [
+          {_key: 'k1', _type: 'link', href: 'google.com', newTab: false},
+          {_key: 'k2', _type: 'color', color: 'red'},
+        ],
+        style: 'normal',
+      },
+    ])
+  })
+
+  it('removes MarkDefs when no annotations are allowed', async () => {
+    const {_regenerateKeys} = exportedForTesting
+    let keyCursor = 0
+
+    const generatedValue = _regenerateKeys(
+      {
+        isTextBlock: isPortableTextTextBlock,
+        isTextSpan: isPortableTextSpan,
+      },
+      initialValue,
+      () => {
+        keyCursor++
+        return `k${keyCursor}`
+      },
+      'span',
+      {annotations: []},
+    )
+
+    // orphaned children marks are removed later in the normalize function
+    expect(generatedValue).toStrictEqual([
+      {
+        _key: 'k1',
+        _type: 'myTestBlockType',
+        children: [
+          {_key: 'a1', _type: 'span', marks: ['link1'], text: 'Block A'},
+          {
+            _key: 'a2',
+            _type: 'span',
+            marks: ['colour1'],
+            text: 'Block B',
+          },
+        ],
+        style: 'normal',
+      },
+    ])
+  })
+
+  it('updates MarkDefs when one annotations is allowed but one is not allowed', async () => {
+    const {_regenerateKeys} = exportedForTesting
+    let keyCursor = 0
+
+    const generatedValue = _regenerateKeys(
+      {
+        isTextBlock: isPortableTextTextBlock,
+        isTextSpan: isPortableTextSpan,
+      },
+      initialValue,
+      () => {
+        keyCursor++
+        return `k${keyCursor}`
+      },
+      'span',
+      // eslint-disable-next-line camelcase
+      {annotations: [{name: 'color', jsonType: 'object', fields: [], __experimental_search: []}]},
+    )
+
+    // orphaned children marks are removed later in the normalize function
+    expect(generatedValue).toStrictEqual([
+      {
+        _key: 'k1',
+        _type: 'myTestBlockType',
+        children: [
+          {_key: 'a1', _type: 'span', marks: ['link1'], text: 'Block A'},
+          {
+            _key: 'a2',
+            _type: 'span',
+            marks: ['colour1'],
+            text: 'Block B',
+          },
+        ],
+        markDefs: [{_key: 'colour1', _type: 'color', color: 'red'}],
+        style: 'normal',
+      },
+    ])
+  })
+})

package/src/editor/plugins/createWithInsertData.ts

@@ -138,6 +138,7 @@ export function createWithInsertData(
             toSlateValue(parsed, {schemaTypes}),
             keyGenerator,
             spanTypeName,
+            schemaTypes,
           )
           // Validate the result
           const validation = validateValue(parsed, schemaTypes, keyGenerator)
@@ -269,15 +270,39 @@ function escapeHtml(str: string) {
  * @internal
  */
 function _regenerateKeys(
-  editor: PortableTextSlateEditor,
+  editor: Pick<PortableTextSlateEditor, 'isTextBlock' | 'isTextSpan'>,
   fragment: Descendant[],
   keyGenerator: () => string,
   spanTypeName: string,
+  editorTypes: Pick<PortableTextMemberSchemaTypes, 'annotations'>,
 ): Descendant[] {
   return fragment.map((node) => {
     const newNode: Descendant = {...node}
     // Ensure the copy has new keys
     if (editor.isTextBlock(newNode)) {
+      const annotations = editorTypes.annotations.map((t) => t.name)
+
+      // Ensure that if there are no annotations, we remove the markDefs
+      if (annotations.length === 0) {
+        const {markDefs, ...NewNodeNoDefs} = newNode
+
+        return {...NewNodeNoDefs, _key: keyGenerator()}
+      }
+
+      // Ensure that all annotations are allowed
+      const hasForbiddenAnnotations = (newNode.markDefs || []).some((def) => {
+        return !annotations.includes(def._type)
+      })
+
+      // if they have forbidden annotations, we remove them and keep the rest
+      if (hasForbiddenAnnotations) {
+        const allowedAnnotations = (newNode.markDefs || []).filter((def) => {
+          return annotations.includes(def._type)
+        })
+
+        return {...newNode, markDefs: allowedAnnotations, _key: keyGenerator()}
+      }
+
       newNode.markDefs = (newNode.markDefs || []).map((def) => {
         const oldKey = def._key
         const newKey = keyGenerator()
@@ -357,3 +382,11 @@ function _insertFragment(
 
   editor.onChange()
 }
+
+/**
+ * functions we don't want to export but want to test
+ * @internal
+ */
+export const exportedForTesting = {
+  _regenerateKeys,
+}

package/src/editor/plugins/createWithPatches.ts

@@ -1,4 +1,6 @@
 /* eslint-disable max-nested-callbacks */
+import {insert, setIfMissing, unset} from '@portabletext/patches/patch-event'
+import {type Patch} from '@portabletext/patches/types'
 import {type Subject} from 'rxjs'
 import {
   type Descendant,
@@ -14,14 +16,12 @@ import {
   type SplitNodeOperation,
 } from 'slate'
 
-import {insert, setIfMissing, unset} from '../../patch/PatchEvent'
 import {
   type EditorChange,
   type PatchObservable,
   type PortableTextMemberSchemaTypes,
   type PortableTextSlateEditor,
 } from '../../types/editor'
-import {type Patch} from '../../types/patch'
 import {createApplyPatch} from '../../utils/applyPatch'
 import {debugWithName} from '../../utils/debug'
 import {fromSlateValue, isEqualToEmptyEditor} from '../../utils/values'

package/src/editor/plugins/createWithUndoRedo.ts

@@ -3,13 +3,13 @@
  * The undo/redo steps are rebased against incoming patches since the step occurred.
  */
 
+import {type Patch} from '@portabletext/patches/types'
 import {DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, parsePatch} from '@sanity/diff-match-patch'
 import {type ObjectSchemaType, type PortableTextBlock} from '@sanity/types'
 import {flatten, isEqual} from 'lodash'
 import {type Descendant, Editor, Operation, Path, type SelectionOperation, Transforms} from 'slate'
 
 import {type PatchObservable, type PortableTextSlateEditor} from '../../types/editor'
-import {type Patch} from '../../types/patch'
 import {debugWithName} from '../../utils/debug'
 import {fromSlateValue} from '../../utils/values'
 import {withPreserveKeys} from '../../utils/withPreserveKeys'

package/src/index.ts

@@ -7,5 +7,4 @@ export type {PortableTextEditorProps} from './editor/PortableTextEditor'
 export {PortableTextEditor} from './editor/PortableTextEditor'
 export * from './types/editor'
 export * from './types/options'
-export * from './types/patch'
-export {compactPatches} from './utils/patches'
+export * from '@portabletext/patches/types'

package/src/types/editor.ts

@@ -1,3 +1,4 @@
+import {type Patch} from '@portabletext/patches/types'
 import {
   type ArraySchemaType,
   type BlockDecoratorDefinition,
@@ -30,7 +31,6 @@ import {type DOMNode} from 'slate-react/dist/utils/dom'
 
 import {type PortableTextEditableProps} from '../editor/Editable'
 import {type PortableTextEditor} from '../editor/PortableTextEditor'
-import {type Patch} from '../types/patch'
 
 /** @beta */
 export interface EditableAPIDeleteOptions {
@@ -467,7 +467,6 @@ export interface BlockDecoratorRenderProps {
   value: string
 }
 /** @beta */
-
 export interface BlockListItemRenderProps {
   block: PortableTextTextBlock
   children: ReactElement
@@ -493,10 +492,12 @@ export type RenderEditableFunction = (props: PortableTextEditableProps) => JSX.E
 export type RenderAnnotationFunction = (props: BlockAnnotationRenderProps) => JSX.Element
 
 /** @beta */
-export type RenderStyleFunction = (props: BlockStyleRenderProps) => JSX.Element
+export type RenderPlaceholderFunction = () => React.ReactNode
 
 /** @beta */
+export type RenderStyleFunction = (props: BlockStyleRenderProps) => JSX.Element
 
+/** @beta */
 export interface BlockStyleRenderProps {
   block: PortableTextTextBlock
   children: ReactElement

package/src/utils/__tests__/dmpToOperations.test.ts

@@ -1,4 +1,5 @@
 import {describe, expect, test} from '@jest/globals'
+import {type DiffMatchPatch} from '@portabletext/patches/types'
 import {makeDiff, makePatches, stringifyPatches} from '@sanity/diff-match-patch'
 import {
   isPortableTextSpan,
@@ -11,7 +12,6 @@ import {
 import {type Descendant, type Operation} from 'slate'
 
 import {type PortableTextSlateEditor} from '../../types/editor'
-import {type DiffMatchPatch} from '../../types/patch'
 import {diffMatchPatch} from '../applyPatch'
 
 describe('operationToPatches: diffMatchPatch', () => {

package/src/utils/applyPatch.ts

@@ -1,4 +1,12 @@
 /* eslint-disable max-statements */
+import {applyAll} from '@portabletext/patches/apply'
+import {
+  type DiffMatchPatch,
+  type InsertPatch,
+  type Patch,
+  type SetPatch,
+  type UnsetPatch,
+} from '@portabletext/patches/types'
 import {
   applyPatches as diffMatchPatchApplyPatches,
   cleanupEfficiency,
@@ -17,15 +25,7 @@ import {
 } from '@sanity/types'
 import {type Descendant, Element, type Node, type Path as SlatePath, Text, Transforms} from 'slate'
 
-import {applyAll} from '../patch/applyPatch'
 import {type PortableTextMemberSchemaTypes, type PortableTextSlateEditor} from '../types/editor'
-import {
-  type DiffMatchPatch,
-  type InsertPatch,
-  type Patch,
-  type SetPatch,
-  type UnsetPatch,
-} from '../types/patch'
 import {debugWithName} from './debug'
 import {toSlateValue} from './values'
 import {KEY_TO_SLATE_ELEMENT} from './weakMaps'

package/src/utils/operationToPatches.ts

@@ -1,3 +1,5 @@
+import {diffMatchPatch, insert, set, setIfMissing, unset} from '@portabletext/patches/patch-event'
+import {type InsertPosition, type Patch} from '@portabletext/patches/types'
 import {type Path, type PortableTextSpan, type PortableTextTextBlock} from '@sanity/types'
 import {get, isUndefined, omitBy} from 'lodash'
 import {
@@ -14,9 +16,7 @@ import {
 } from 'slate'
 
 import {type PatchFunctions} from '../editor/plugins/createWithPatches'
-import {diffMatchPatch, insert, set, setIfMissing, unset} from '../patch/PatchEvent'
 import {type PortableTextMemberSchemaTypes, type PortableTextSlateEditor} from '../types/editor'
-import {type InsertPosition, type Patch} from '../types/patch'
 import {debugWithName} from './debug'
 import {fromSlateValue} from './values'
 

package/src/utils/validateValue.ts

@@ -1,3 +1,4 @@
+import {insert, set, setIfMissing, unset} from '@portabletext/patches/patch-event'
 import {
   isPortableTextTextBlock,
   type PortableTextBlock,
@@ -6,7 +7,6 @@ import {
 } from '@sanity/types'
 import {flatten, isPlainObject, uniq} from 'lodash'
 
-import {insert, set, setIfMissing, unset} from '../patch/PatchEvent'
 import {type InvalidValueResolution, type PortableTextMemberSchemaTypes} from '../types/editor'
 import {EMPTY_MARKDEFS} from './values'
 

package/src/patch/PatchEvent.ts

@@ -1,33 +0,0 @@
-import {type PathSegment} from '@sanity/types'
-import {flatten} from 'lodash'
-
-import {type Patch} from '../types/patch'
-import {diffMatchPatch, insert, prefixPath, set, setIfMissing, unset} from './patches'
-
-type PatchArg = Patch | Array<Patch>
-
-export default class PatchEvent {
-  static from(...patches: Array<PatchArg>) {
-    return new PatchEvent(flatten(patches))
-  }
-
-  patches: Array<Patch>
-
-  constructor(patches: Array<Patch>) {
-    this.patches = patches
-  }
-
-  prepend(...patches: Array<PatchArg>): PatchEvent {
-    return PatchEvent.from([...flatten(patches), ...this.patches])
-  }
-
-  append(...patches: Array<PatchArg>): PatchEvent {
-    return PatchEvent.from([...this.patches, ...flatten(patches)])
-  }
-
-  prefixAll(segment: PathSegment): PatchEvent {
-    return PatchEvent.from(this.patches.map((patch) => prefixPath(patch, segment)))
-  }
-}
-
-export {diffMatchPatch, insert, PatchEvent, set, setIfMissing, unset}

package/src/patch/applyPatch.ts

@@ -1,29 +0,0 @@
-import {isObject, isString} from 'lodash'
-
-import applyArrayPatch from './array'
-import applyObjectPatch from './object'
-import applyPrimitivePatch from './primitive'
-import applyStringPatch from './string'
-
-export function applyAll(value: any, patches: any[]) {
-  return patches.reduce(_apply, value)
-}
-
-function applyPatch(value: string, patch: {type: string; path: any[]; value: any}) {
-  if (Array.isArray(value)) {
-    return applyArrayPatch(value, patch as any)
-  }
-  if (isString(value)) {
-    return applyStringPatch(value, patch)
-  }
-  if (isObject(value)) {
-    return applyObjectPatch(value, patch)
-  }
-  return applyPrimitivePatch(value, patch)
-}
-
-export default function _apply(value: string, patch: {type: string; path: any[]; value: any}) {
-  const res = applyPatch(value, patch)
-  // console.log('applyPatch(%o, %o) : %o (noop? %o)', value, patch, res, value === res)
-  return res
-}