feat(core): global copy paste

dev/studio-e2e-testing/sanity.config.ts

@@ -7,8 +7,6 @@ import {muxInput} from 'sanity-plugin-mux-input'
 import {imageAssetSource} from 'sanity-test-studio/assetSources'
 import {resolveDocumentActions as documentActions} from 'sanity-test-studio/documentActions'
 import {assistFieldActionGroup} from 'sanity-test-studio/fieldActions/assistFieldActionGroup'
-import {copyAction} from 'sanity-test-studio/fieldActions/copyAction'
-import {pasteAction} from 'sanity-test-studio/fieldActions/pasteAction'
 import {resolveInitialValueTemplates} from 'sanity-test-studio/initialValueTemplates'
 import {customInspector} from 'sanity-test-studio/inspectors/custom'
 import {languageFilter} from 'sanity-test-studio/plugins/language-filter'
@@ -53,7 +51,7 @@ export default defineConfig({
     },
     unstable_fieldActions: (prev, ctx) => {
       if (['fieldActionsTest', 'stringsTest'].includes(ctx.documentType)) {
-        return [...prev, assistFieldActionGroup, copyAction, pasteAction]
+        return [...prev, assistFieldActionGroup]
       }
 
       return prev

dev/test-studio/sanity.config.ts

@@ -38,8 +38,6 @@ import {
 import {GoogleLogo, TailwindLogo, VercelLogo} from './components/workspaceLogos'
 import {resolveDocumentActions as documentActions} from './documentActions'
 import {assistFieldActionGroup} from './fieldActions/assistFieldActionGroup'
-import {copyAction} from './fieldActions/copyAction'
-import {pasteAction} from './fieldActions/pasteAction'
 import {resolveInitialValueTemplates} from './initialValueTemplates'
 import {customInspector} from './inspectors/custom'
 import {testStudioLocaleBundles} from './locales'
@@ -89,11 +87,13 @@ const sharedSettings = definePlugin({
       return prev
     },
     unstable_fieldActions: (prev, ctx) => {
+      const defaultActions = [...prev]
+
       if (['fieldActionsTest', 'stringsTest'].includes(ctx.documentType)) {
-        return [...prev, assistFieldActionGroup, copyAction, pasteAction]
+        return [...defaultActions, assistFieldActionGroup]
       }
 
-      return prev
+      return defaultActions
     },
     newDocumentOptions,
     comments: {

dev/test-studio/schema/standard/arrays.tsx

@@ -1,5 +1,5 @@
 import {ImageIcon, OlistIcon} from '@sanity/icons'
-import {defineField, defineType} from 'sanity'
+import {defineArrayMember, defineField, defineType} from 'sanity'
 
 export const topLevelArrayType = defineType({
   name: 'topLevelArrayType',
@@ -143,7 +143,7 @@ export default defineType({
         },
       ],
     },
-    {
+    defineField({
       name: 'arrayOfMultipleTypes',
       title: 'Array of multiple types',
       type: 'array',
@@ -155,7 +155,7 @@ export default defineType({
         {
           type: 'book',
         },
-        {
+        defineArrayMember({
           type: 'object',
           name: 'color',
           title: 'Color with a long title',
@@ -174,10 +174,32 @@ export default defineType({
               name: 'name',
               type: 'string',
             },
+            defineField({
+              name: 'nestedArray',
+              title: 'Nested array',
+              type: 'array',
+              of: [
+                defineArrayMember({
+                  type: 'object',
+                  name: 'color',
+                  title: 'Color with a long title',
+                  fields: [
+                    {
+                      name: 'title',
+                      type: 'string',
+                    },
+                    {
+                      name: 'name',
+                      type: 'string',
+                    },
+                  ],
+                }),
+              ],
+            }),
           ],
-        },
+        }),
       ],
-    },
+    }),
     {
       name: 'arrayOfMultipleTypesPopover',
       title: 'Array of multiple types (modal.type=popover)',

dev/test-studio/schema/standard/portableText/allTheBellsAndWhistles.ts

@@ -225,11 +225,31 @@ export const ptAllTheBellsAndWhistlesType = defineType({
             }),
             defineField({
               title: 'Box Content',
-              name: 'body',
+              name: 'content',
               type: 'array',
               of: [{type: 'block'}],
               validation: (rule) => rule.required().error('Must have content'),
             }),
+            defineField({
+              title: 'Nested object',
+              name: 'nestedObject',
+              type: 'object',
+              fields: [
+                defineField({
+                  name: 'title',
+                  title: 'Title',
+                  type: 'string',
+                  validation: (rule) => rule.required().warning('Should have a title'),
+                }),
+                defineField({
+                  title: 'Box Content',
+                  name: 'body',
+                  type: 'array',
+                  of: [{type: 'block'}],
+                  validation: (rule) => rule.required().error('Must have content'),
+                }),
+              ],
+            }),
           ],
           components: {
             preview: InfoBoxPreview as any,

package.json

@@ -102,7 +102,7 @@
     "@bjoerge/mutiny": "^0.5.3",
     "@google-cloud/storage": "^7.11.0",
     "@jest/globals": "^29.7.0",
-    "@playwright/test": "1.41.2",
+    "@playwright/test": "1.44.1",
     "@repo/package.config": "workspace:*",
     "@repo/tsconfig": "workspace:*",
     "@sanity/client": "^6.21.0",

packages/@sanity/types/src/schema/asserters.ts

@@ -10,6 +10,8 @@ import {
   type BooleanSchemaType,
   type DeprecatedSchemaType,
   type DeprecationConfiguration,
+  type FileSchemaType,
+  type ImageSchemaType,
   type NumberSchemaType,
   type ObjectSchemaType,
   type ReferenceSchemaType,
@@ -108,6 +110,16 @@ export function isReferenceSchemaType(type: unknown): type is ReferenceSchemaTyp
   return isRecord(type) && (type.name === 'reference' || isReferenceSchemaType(type.type))
 }
 
+/** @internal */
+export function isImageSchemaType(type: unknown): type is ImageSchemaType {
+  return isRecord(type) && (type.name === 'image' || isImageSchemaType(type.type))
+}
+
+/** @internal */
+export function isFileSchemaType(type: unknown): type is FileSchemaType {
+  return isRecord(type) && (type.name === 'file' || isFileSchemaType(type.type))
+}
+
 /** @internal */
 export function isDeprecatedSchemaType<TSchemaType extends BaseSchemaType>(
   type: TSchemaType,

packages/sanity/package.json

@@ -256,8 +256,8 @@
   "devDependencies": {
     "@jest/expect": "^29.7.0",
     "@jest/globals": "^29.7.0",
-    "@playwright/experimental-ct-react": "1.41.2",
-    "@playwright/test": "1.41.2",
+    "@playwright/experimental-ct-react": "1.44.1",
+    "@playwright/test": "1.44.1",
     "@repo/package.config": "workspace:*",
     "@sanity/codegen": "3.49.0",
     "@sanity/generate-help-url": "^3.0.0",

packages/sanity/playwright-ct.config.ts

@@ -6,6 +6,7 @@ import {defineConfig, devices} from '@playwright/experimental-ct-react'
 const TESTS_PATH = path.join(__dirname, 'playwright-ct', 'tests')
 const HTML_REPORT_PATH = path.join(__dirname, 'playwright-ct', 'report')
 const ARTIFACT_OUTPUT_PATH = path.join(__dirname, 'playwright-ct', 'results')
+const isCI = !!process.env.CI
 
 /**
  * See https://playwright.dev/docs/test-configuration.
@@ -36,18 +37,19 @@ export default defineConfig({
   ],
 
   /* Maximum time one test can run for. */
-  timeout: 10 * 1000,
+  timeout: 30 * 1000,
   expect: {
     // Maximum time expect() should wait for the condition to be met.
-    timeout: 5 * 1000,
+    timeout: 10 * 1000,
   },
 
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
     /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
     actionTimeout: 40 * 1000,
     /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: 'on-first-retry',
+    trace: isCI ? 'on-all-retries' : 'retain-on-failure',
+    video: isCI ? 'on-first-retry' : 'retain-on-failure',
     /* Port to use for Playwright component endpoint. */
     ctPort: 3100,
     /* Configure Playwright vite config */
@@ -69,8 +71,29 @@ export default defineConfig({
 
   /* Configure projects for major browsers */
   projects: [
-    {name: 'chromium', use: {...devices['Desktop Chrome']}},
-    {name: 'firefox', use: {...devices['Desktop Firefox']}},
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+        permissions: ['clipboard-read', 'clipboard-write'],
+        contextOptions: {
+          // chromium-specific permissions
+          permissions: ['clipboard-read', 'clipboard-write'],
+        },
+      },
+    },
+    {
+      name: 'firefox',
+      use: {
+        ...devices['Desktop Firefox'],
+        launchOptions: {
+          firefoxUserPrefs: {
+            'dom.events.asyncClipboard.readText': true,
+            'dom.events.testing.asyncClipboard': true,
+          },
+        },
+      },
+    },
     {name: 'webkit', use: {...devices['Desktop Safari']}},
   ],
 })

packages/sanity/playwright-ct/tests/fixtures/copyPasteFixture.ts

@@ -0,0 +1,89 @@
+import {test as base} from '@playwright/experimental-ct-react'
+
+export const test = base.extend<{
+  getClipboardItemByMimeTypeAsText: (mimeType: string) => Promise<string | null>
+  setClipboardItems: (items: ClipboardItem[]) => Promise<void>
+  getClipboardItems: () => Promise<ClipboardItem[]>
+  getClipboardItemsAsText: () => Promise<string>
+}>({
+  page: async ({page}, use) => {
+    const setupClipboardMocks = async () => {
+      await page.addInitScript(() => {
+        const mockClipboard = {
+          read: () => {
+            return Promise.resolve((window as any).__clipboardItems)
+          },
+          write: (newItems: ClipboardItem[]) => {
+            ;(window as any).__clipboardItems = newItems
+
+            return Promise.resolve()
+          },
+          readText: () => {
+            const items = (window as any).__clipboardItems as ClipboardItem[]
+            const textItem = items.find((item) => item.types.includes('text/plain'))
+            return textItem
+              ? textItem.getType('text/plain').then((blob: Blob) => blob.text())
+              : Promise.resolve('')
+          },
+          writeText: (text: string) => {
+            const textBlob = new Blob([text], {type: 'text/plain'})
+            ;(window as any).__clipboardItems = [new ClipboardItem({'text/plain': textBlob})]
+            return Promise.resolve()
+          },
+        }
+        Object.defineProperty(Object.getPrototypeOf(navigator), 'clipboard', {
+          value: mockClipboard,
+          writable: false,
+        })
+        ;(window as any).__clipboardItems = []
+      })
+    }
+
+    await setupClipboardMocks()
+
+    page.on('framenavigated', async () => {
+      await setupClipboardMocks()
+    })
+
+    await use(page)
+  },
+
+  setClipboardItems: async ({page}, use) => {
+    await use(async (items: ClipboardItem[]) => {
+      ;(window as any).__clipboardItems = items
+    })
+  },
+
+  getClipboardItems: async ({page}, use) => {
+    await use(() => {
+      return page.evaluate(() => navigator.clipboard.read())
+    })
+  },
+
+  getClipboardItemsAsText: async ({page}, use) => {
+    await use(async () => {
+      return page.evaluate(async () => {
+        const items = await navigator.clipboard.read()
+        const textItem = items.find((item) => item.types.includes('text/plain'))
+
+        return textItem
+          ? textItem.getType('text/plain').then((blob: Blob) => blob.text())
+          : Promise.resolve('')
+      })
+    })
+  },
+
+  getClipboardItemByMimeTypeAsText: async ({page}, use) => {
+    await use(async (mimeType: string) => {
+      return page.evaluate(async (mime) => {
+        const items = await navigator.clipboard.read()
+        const textItem = items.find((item) => item.types.includes(mime))
+        const content = textItem ? textItem.getType(mime).then((blob: Blob) => blob.text()) : null
+
+        return content
+      }, mimeType)
+    })
+  },
+})
+
+export const {expect} = test