gt-sanity 4.0.15 → 4.0.16

package/dist/index.js

@@ -2775,7 +2775,7 @@ const useTranslations = () => {
     ] }) })
   }
 ) : null;
-var version = "4.0.15";
+var version = "4.0.16";
 function buildDebugInfo({
   secrets,
   preferences,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt-sanity",
-  "version": "4.0.15",
+  "version": "4.0.16",
   "description": "General Translation integration with Sanity",
   "keywords": [
     "sanity",
@@ -48,7 +48,7 @@
     "jsonpointer": "^5.0.1",
     "lodash.merge": "^4.6.2",
     "sanity-plugin-internationalized-array": "^5.1.27",
-    "generaltranslation": "9.4.0"
+    "generaltranslation": "9.4.1"
   },
   "devDependencies": {
     "@portabletext/types": "^2.0.15",

package/src/adapter/__tests__/api.test.ts

@@ -63,117 +63,181 @@ describe('Sanity API adapter', () => {
     });
   });
 
-  it('canonicalizes the optional source locale when enqueueing files', async () => {
-    fetchMock.mockImplementation(async (request) => {
-      const body = JSON.parse(await new Request(request).text()) as {
-        sourceLocale?: string;
-        targetLocales: string[];
-      };
-      expect(body.sourceLocale).toBe('en-US');
-      expect(body.targetLocales).toEqual(['es-ES']);
-      return Response.json({
-        jobData: {},
-        locales: [],
-        message: 'Enqueued files',
+  it.each([
+    ['source', 'target'],
+    ['en-us', 'es-es'],
+  ])(
+    'canonicalizes enqueue locales %s / %s',
+    async (sourceLocale, targetLocale) => {
+      fetchMock.mockImplementation(async (request) => {
+        const body = JSON.parse(await new Request(request).text()) as {
+          sourceLocale?: string;
+          targetLocales: string[];
+        };
+        expect(body.sourceLocale).toBe('en-US');
+        expect(body.targetLocales).toEqual(['es-ES']);
+        return Response.json({
+          jobData: {},
+          locales: [],
+          message: 'Enqueued files',
+        });
       });
-    });
 
-    await api.enqueueFiles([{ fileId: 'file-id', versionId: 'version-id' }], {
-      sourceLocale: 'source',
-      targetLocales: ['target'],
-    });
+      await api.enqueueFiles([{ fileId: 'file-id', versionId: 'version-id' }], {
+        sourceLocale,
+        targetLocales: [targetLocale],
+      });
 
-    expect(fetchMock).toHaveBeenCalledOnce();
-  });
+      expect(fetchMock).toHaveBeenCalledOnce();
+    }
+  );
+
+  it.each([
+    ['source', 'target'],
+    ['en-us', 'es-es'],
+  ])(
+    'canonicalizes upload locales %s / %s',
+    async (sourceLocale, targetLocale) => {
+      fetchMock.mockImplementation(async (request) => {
+        const body = JSON.parse(await new Request(request).text()) as {
+          sourceLocale: string;
+          data: Array<{
+            source: { locale: string };
+            translations: Array<{ locale: string }>;
+          }>;
+        };
+        expect(body.sourceLocale).toBe('en-US');
+        expect(body.data[0].source.locale).toBe('en-US');
+        expect(body.data[0].translations[0].locale).toBe('es-ES');
+        return Response.json({
+          uploadedFiles: [],
+          count: 0,
+          message: 'Uploaded files',
+        });
+      });
+
+      await api.uploadTranslations(
+        [
+          {
+            source: {
+              content: 'source',
+              fileName: 'document.html',
+              fileFormat: 'HTML',
+              locale: sourceLocale,
+            },
+            translations: [
+              {
+                content: 'translation',
+                fileName: 'document.html',
+                fileFormat: 'HTML',
+                locale: targetLocale,
+              },
+            ],
+          },
+        ],
+        { sourceLocale }
+      );
 
-  it('canonicalizes translation locales when uploading translations', async () => {
+      expect(fetchMock).toHaveBeenCalledOnce();
+    }
+  );
+
+  it('canonicalizes source upload locales without mutating input', async () => {
     fetchMock.mockImplementation(async (request) => {
-      const body = JSON.parse(await new Request(request).text()) as {
-        sourceLocale: string;
-        data: Array<{ translations: Array<{ locale: string }> }>;
-      };
-      expect(body.sourceLocale).toBe('en-US');
-      expect(body.data[0].translations[0].locale).toBe('es-ES');
+      const body = JSON.parse(await new Request(request).text());
+      expect(body).toMatchObject({
+        sourceLocale: 'en-US',
+        data: [{ source: { locale: 'en-US' } }],
+      });
       return Response.json({
         uploadedFiles: [],
         count: 0,
         message: 'Uploaded files',
       });
     });
-
-    await api.uploadTranslations(
-      [
-        {
-          source: {
-            content: 'source',
-            fileName: 'document.html',
-            fileFormat: 'HTML',
-            locale: 'source',
-          },
-          translations: [
-            {
-              content: 'translation',
-              fileName: 'document.html',
-              fileFormat: 'HTML',
-              locale: 'target',
-            },
-          ],
+    const files = [
+      {
+        source: {
+          content: 'source',
+          fileName: 'document.html',
+          fileFormat: 'HTML' as const,
+          locale: 'en-us',
         },
-      ],
-      { sourceLocale: 'source' }
-    );
+      },
+    ];
 
-    expect(fetchMock).toHaveBeenCalledOnce();
-  });
+    await api.uploadSourceFiles(files, { sourceLocale: 'en-us' });
 
-  it('canonicalizes the locale when downloading one file', async () => {
-    vi.mocked(downloadFile).mockResolvedValue(
-      result({ data: Buffer.from('translated').toString('base64') })
-    );
-
-    await expect(
-      api.downloadFile({ fileId: 'file-id', locale: 'target' })
-    ).resolves.toBe('translated');
-    expect(downloadFile).toHaveBeenCalledWith(
-      expect.objectContaining({
-        query: expect.objectContaining({ locale: 'es-ES' }),
-      })
-    );
+    expect(fetchMock).toHaveBeenCalledOnce();
+    expect(files[0].source.locale).toBe('en-us');
   });
 
-  it('maps batch-download locales in both directions', async () => {
+  it('canonicalizes project setup locales', async () => {
     fetchMock.mockImplementation(async (request) => {
-      const body = JSON.parse(await new Request(request).text()) as Array<{
-        locale?: string;
-      }>;
-      expect(body).toEqual([{ fileId: 'file-id', locale: 'es-ES' }]);
-      return Response.json({
-        files: [
-          {
-            id: 'id',
-            branchId: 'branch-id',
-            fileId: 'file-id',
-            locale: 'es-ES',
-            versionId: 'version-id',
-            fileName: 'document.html',
-            data: Buffer.from('translated').toString('base64'),
-            metadata: {},
-            fileFormat: 'HTML',
-          },
-        ],
-        count: 1,
-        pending: [],
-      });
+      const body = JSON.parse(await new Request(request).text());
+      expect(body.locales).toEqual(['en-US', 'es-ES']);
+      return Response.json({ status: 'completed' });
     });
 
-    const response = await api.downloadFileBatch([
-      { fileId: 'file-id', locale: 'target' },
-    ]);
+    await api.setupProject([], { locales: ['source', 'es-es'] });
 
     expect(fetchMock).toHaveBeenCalledOnce();
-    expect(response.files[0].locale).toBe('target');
   });
 
+  it.each(['target', 'es-es'])(
+    'canonicalizes single download locale %s',
+    async (locale) => {
+      vi.mocked(downloadFile).mockResolvedValue(
+        result({ data: Buffer.from('translated').toString('base64') })
+      );
+
+      await expect(
+        api.downloadFile({ fileId: 'file-id', locale })
+      ).resolves.toBe('translated');
+      expect(downloadFile).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: expect.objectContaining({ locale: 'es-ES' }),
+        })
+      );
+    }
+  );
+
+  it.each(['target', 'es-es'])(
+    'maps batch-download locale %s in both directions',
+    async (locale) => {
+      fetchMock.mockImplementation(async (request) => {
+        const body = JSON.parse(await new Request(request).text()) as Array<{
+          locale?: string;
+        }>;
+        expect(body).toEqual([{ fileId: 'file-id', locale: 'es-ES' }]);
+        return Response.json({
+          files: [
+            {
+              id: 'id',
+              branchId: 'branch-id',
+              fileId: 'file-id',
+              locale: 'es-ES',
+              versionId: 'version-id',
+              fileName: 'document.html',
+              data: Buffer.from('translated').toString('base64'),
+              metadata: {},
+              fileFormat: 'HTML',
+            },
+          ],
+          count: 1,
+          pending: [],
+        });
+      });
+
+      const response = await api.downloadFileBatch([
+        { fileId: 'file-id', locale },
+      ]);
+
+      expect(fetchMock).toHaveBeenCalledOnce();
+      expect(response.files[0].locale).toBe('target');
+    }
+  );
+
   it('does not request an empty batch download', async () => {
     await expect(api.downloadFileBatch([])).resolves.toEqual({
       files: [],