gt-sanity 2.0.21 → 2.1.1

package/src/schema/createInternationalizedArrayTypes.ts

@@ -0,0 +1,209 @@
+import { getLocaleProperties } from 'generaltranslation';
+import { FieldProps, SchemaTypeDefinition } from 'sanity';
+import {
+  InternationalizedArrayInput,
+  InternationalizedValueItem,
+} from './InternationalizedArrayInput';
+import {
+  FieldLevelFieldType,
+  FieldLevelUIComponents,
+  GTFieldLevelLocalizationConfig,
+} from './types';
+
+const DEFAULT_TYPE_PREFIX = 'internationalizedArray';
+
+export type CreateInternationalizedArrayTypesOptions = {
+  sourceLocale: string;
+  locales: string[];
+  fieldTypes: FieldLevelFieldType[];
+  languageTitles?: Record<string, string>;
+  getLanguageTitle?: (locale: string) => string;
+  typePrefix?: string;
+  includeCompatibilityTypes?: boolean;
+  components?: FieldLevelUIComponents;
+};
+
+/**
+ * Resolve the components to attach to generated types. Each slot can be a
+ * custom component, `false` (detach — Sanity's default rendering), or
+ * undefined (GT's default). The `field` level-reset wrapper only makes sense
+ * alongside GT's inline input, so its default follows the resolved `input`.
+ */
+function resolveComponents(overrides: FieldLevelUIComponents | undefined): {
+  input?: unknown;
+  item?: unknown;
+  field?: unknown;
+} {
+  const input =
+    overrides?.input === false
+      ? undefined
+      : (overrides?.input ?? InternationalizedArrayInput);
+  const item =
+    overrides?.item === false
+      ? undefined
+      : (overrides?.item ?? InternationalizedValueItem);
+  const defaultField =
+    input === InternationalizedArrayInput
+      ? // Reset the field level so inline per-locale inputs don't inherit
+        // nested-object indentation.
+        (fieldProps: FieldProps) =>
+          fieldProps.renderDefault({ ...fieldProps, level: 0 })
+      : undefined;
+  const field =
+    overrides?.field === false ? undefined : (overrides?.field ?? defaultField);
+  return { input, item, field };
+}
+
+function capitalize(value: string): string {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function fieldTypeName(fieldType: FieldLevelFieldType): string {
+  return typeof fieldType === 'string' ? fieldType : fieldType.name;
+}
+
+/** Build the generated `value` field definition for a localizable field type. */
+function valueField(fieldType: FieldLevelFieldType): Record<string, unknown> {
+  if (fieldType === 'string' || fieldType === 'text') {
+    return { name: 'value', type: fieldType, title: 'Value' };
+  }
+  if (fieldType === 'block') {
+    return {
+      name: 'value',
+      type: 'array',
+      title: 'Value',
+      of: [{ type: 'block' }],
+    };
+  }
+  // Custom object form: pass the user definition through under `value`.
+  const { name: _name, ...rest } = fieldType;
+  return { name: 'value', title: 'Value', ...rest };
+}
+
+function makeLanguageTitle(
+  options: CreateInternationalizedArrayTypesOptions
+): (locale: string) => string {
+  const { languageTitles, getLanguageTitle, sourceLocale } = options;
+  return (locale: string) =>
+    getLanguageTitle?.(locale) ??
+    languageTitles?.[locale] ??
+    getLocaleProperties(locale, sourceLocale).name ??
+    locale;
+}
+
+function buildTypesForPrefix(
+  prefix: string,
+  options: CreateInternationalizedArrayTypesOptions
+): SchemaTypeDefinition[] {
+  const { sourceLocale, locales, fieldTypes } = options;
+  const languageTitle = makeLanguageTitle(options);
+  const components = resolveComponents(options.components);
+
+  return fieldTypes.map((fieldType) => {
+    const typeName = `${prefix}${capitalize(fieldTypeName(fieldType))}`;
+    const valueTypeName = `${typeName}Value`;
+
+    // Locale identity comes from gtPlugin (sourceLocale + locales); surfaced
+    // on both the array type (per-locale add buttons) and the value object
+    // (inline item label + source-locale remove guard).
+    const gtInternationalizedArray = {
+      sourceLocale,
+      locales,
+      titles: Object.fromEntries(
+        [sourceLocale, ...locales].map((locale) => [
+          locale,
+          languageTitle(locale),
+        ])
+      ),
+    };
+
+    const valueObject = {
+      type: 'object',
+      name: valueTypeName,
+      ...(components.item ? { components: { item: components.item } } : {}),
+      fields: [
+        {
+          name: 'language',
+          type: 'string',
+          title: 'Language',
+          readOnly: true,
+          // GT's inline item shows the locale as the value field's label;
+          // with a custom or detached item, keep the field visible so the
+          // locale is still discoverable in default/dialog rendering.
+          hidden: components.item === InternationalizedValueItem,
+        },
+        valueField(fieldType),
+      ],
+      options: { gtInternationalizedArray },
+      preview: {
+        select: { language: 'language', value: 'value' },
+        prepare(selection: { language?: string; value?: unknown }) {
+          const localeLabel = selection.language
+            ? languageTitle(selection.language)
+            : 'Unknown';
+          return {
+            title:
+              typeof selection.value === 'string'
+                ? selection.value
+                : localeLabel,
+            subtitle: localeLabel,
+          };
+        },
+      },
+    };
+
+    const arrayComponents = {
+      ...(components.input ? { input: components.input } : {}),
+      ...(components.field ? { field: components.field } : {}),
+    };
+
+    return {
+      name: typeName,
+      type: 'array',
+      ...(Object.keys(arrayComponents).length
+        ? { components: arrayComponents }
+        : {}),
+      of: [valueObject],
+      options: { gtInternationalizedArray },
+    } as unknown as SchemaTypeDefinition;
+  });
+}
+
+/**
+ * Generate `internationalizedArray*` schema types from gtPlugin locale config.
+ *
+ * Each generated type is an array of `{ _key, _type, language, value }` objects
+ * matching `sanity-plugin-internationalized-array`, giving zero-migration
+ * interop with existing internationalized-array data.
+ *
+ * When `typePrefix` is customized and `includeCompatibilityTypes` is true, the
+ * standard `internationalizedArray*` names are also generated so existing
+ * content keeps resolving.
+ */
+export function createInternationalizedArrayTypes(
+  options: CreateInternationalizedArrayTypesOptions
+): SchemaTypeDefinition[] {
+  const prefix = options.typePrefix ?? DEFAULT_TYPE_PREFIX;
+  const includeCompatibilityTypes = options.includeCompatibilityTypes ?? true;
+
+  const types = buildTypesForPrefix(prefix, options);
+
+  if (includeCompatibilityTypes && prefix !== DEFAULT_TYPE_PREFIX) {
+    types.push(...buildTypesForPrefix(DEFAULT_TYPE_PREFIX, options));
+  }
+
+  return types;
+}
+
+export function resolveFieldLevelConfig(
+  config: GTFieldLevelLocalizationConfig | undefined
+): Required<Pick<GTFieldLevelLocalizationConfig, 'enabled' | 'fieldTypes'>> &
+  GTFieldLevelLocalizationConfig {
+  return {
+    enabled: false,
+    fieldTypes: ['string', 'text'],
+    typePrefix: DEFAULT_TYPE_PREFIX,
+    includeCompatibilityTypes: true,
+    ...config,
+  };
+}

package/src/schema/types.ts

@@ -0,0 +1,84 @@
+import type { ComponentType } from 'react';
+import type {
+  ArrayOfObjectsInputProps,
+  FieldProps,
+  ObjectItemProps,
+} from 'sanity';
+
+/**
+ * A localizable field type. Built-in shortcuts (`string`, `text`, `block`) map
+ * to generated `value` field definitions; an object form supplies a custom
+ * `value` field definition verbatim.
+ */
+export type FieldLevelFieldType =
+  | 'string'
+  | 'text'
+  | 'block'
+  | {
+      /** Suffix used in the generated type name, e.g. `seo` → `internationalizedArraySeo`. */
+      name: string;
+      /** Sanity type of the generated `value` field (e.g. an object type name). */
+      type: string;
+      title?: string;
+      of?: unknown[];
+      fields?: unknown[];
+      options?: Record<string, unknown>;
+    };
+
+/**
+ * Studio component overrides for generated `internationalizedArray*` types.
+ *
+ * Each slot defaults to GT's inline UI (per-locale labeled inputs with
+ * remove buttons and add-locale buttons). Pass a component to replace a
+ * slot, or `false` to detach GT's component and fall back to Sanity's
+ * default rendering. Translation is unaffected either way — it operates on
+ * the stored `{_key, language, value}` data, not on the components.
+ */
+export type FieldLevelUIComponents = {
+  /** Input for the generated array types. Default: GT's inline input. */
+  input?: ComponentType<ArrayOfObjectsInputProps> | false;
+  /** Item for the generated `*Value` objects. Default: GT's inline item. */
+  item?: ComponentType<ObjectItemProps> | false;
+  /**
+   * Field wrapper for the generated array types. Defaults to a wrapper that
+   * resets the field level (removes nested-object indentation) — but only
+   * while GT's default input is in use; with a custom or disabled `input`,
+   * this defaults to Sanity's standard field rendering.
+   */
+  field?: ComponentType<FieldProps> | false;
+};
+
+/**
+ * Field-level localization options, mirroring the useful parts of
+ * `sanity-plugin-internationalized-array` while keeping `sourceLocale` /
+ * `locales` from `gtPlugin()` as the only source of locale identity.
+ */
+export type GTFieldLevelLocalizationConfig = {
+  /** Generate `internationalizedArray*` schema types + input components. Default `false`. */
+  enabled?: boolean;
+  /** Which field types to generate. Default `['string', 'text']`. */
+  fieldTypes?: FieldLevelFieldType[];
+  /** Per-locale display labels shown in the Studio input. */
+  languageTitles?: Record<string, string>;
+  /** Compute a display label for a locale (overrides `languageTitles`). */
+  getLanguageTitle?: (locale: string) => string;
+  /** Prefix for generated type names. Default `'internationalizedArray'`. */
+  typePrefix?: string;
+  /**
+   * When `typePrefix` is customized, also generate `internationalizedArray*`
+   * aliases for interop with existing data. Default `true`.
+   */
+  includeCompatibilityTypes?: boolean;
+  /**
+   * Override or detach the Studio components attached to generated types.
+   * Use this to keep your own UI (or Sanity's default) while GT generates
+   * the schema types and handles translation.
+   */
+  components?: FieldLevelUIComponents;
+
+  // Deferred past v1 (need a richer custom input first):
+  // buttonLocations, buttonAddAll, languageDisplay, select.
+  //
+  // Item field names are fixed (not configurable) in v1: locale in `language`,
+  // data in `value`, random `_key` — matching the reference plugin.
+};

package/src/serialization/__tests__/BaseDocumentDeserializer/baseDeserialization.test.ts

@@ -6,12 +6,12 @@ import {
   PortableTextTextBlock,
 } from 'sanity';
 import { beforeEach, expect, test, vi } from 'vitest';
+import { BaseDocumentDeserializer } from '../../deserialize/BaseDocumentDeserializer';
+import { BaseDocumentSerializer } from '../../serialize/index';
 import {
-  BaseDocumentDeserializer,
-  BaseDocumentSerializer,
   customBlockDeserializers,
   defaultStopTypes,
-} from '../../index';
+} from '../../BaseSerializationConfig';
 import {
   annotationAndInlineBlocks,
   documentLevelArticle,

package/src/serialization/__tests__/BaseDocumentMerger/baseMerge.test.ts

@@ -1,6 +1,6 @@
 import { PortableTextBlock } from 'sanity';
 import { expect, test } from 'vitest';
-import { BaseDocumentMerger } from '../../index';
+import { BaseDocumentMerger } from '../../BaseDocumentMerger';
 import { getNewDocument } from './utils';
 import documentLevelArticle from '../__fixtures__/documentLevelArticle.json';
 

package/src/serialization/__tests__/BaseDocumentMerger/documentLevelMerge.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'vitest';
-import { BaseDocumentMerger } from '../../index';
+import { BaseDocumentMerger } from '../../BaseDocumentMerger';
 import { getNewDocument, getNewObject } from './utils';
 import documentLevelArticle from '../__fixtures__/documentLevelArticle.json';
 

package/src/serialization/__tests__/BaseDocumentMerger/fieldLevelMerge.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'vitest';
-import { BaseDocumentMerger } from '../../index';
+import { BaseDocumentMerger } from '../../BaseDocumentMerger';
 import { getDeserialized } from '../helpers';
 import { getNewFieldLevelDocument, getNewObject } from './utils';
 import clone from 'just-clone';

package/src/serialization/__tests__/BaseDocumentSerializer/baseSerialization.test.ts

@@ -1,10 +1,10 @@
 import { PortableTextBlock } from 'sanity';
 import { describe, expect, test, vi } from 'vitest';
+import { BaseDocumentSerializer } from '../../serialize/index';
 import {
-  BaseDocumentSerializer,
   customSerializers,
   defaultStopTypes,
-} from '../../index';
+} from '../../BaseSerializationConfig';
 import {
   addedCustomSerializers,
   createCustomInnerHTML,

package/src/serialization/__tests__/BaseDocumentSerializer/documentInlineMarks.test.ts

@@ -2,9 +2,11 @@ import { SanityDocument } from 'sanity';
 import { expect, test } from 'vitest';
 import { getDeserialized } from '../helpers';
 import { docWithInlineMarks, findByClass, getHTMLNode, schema } from './utils';
-import { attachGTData, BaseDocumentSerializer, customSerializers } from '../..';
+import { attachGTData } from '../../data';
+import { BaseDocumentSerializer } from '../../serialize/index';
+import { customSerializers } from '../../BaseSerializationConfig';
 import { TranslationLevel } from '../../types';
-import { defaultStopTypes } from '../..';
+import { defaultStopTypes } from '../../BaseSerializationConfig';
 import merge from 'lodash.merge';
 import { PortableTextHtmlComponents } from '@portabletext/to-html';
 

package/src/serialization/__tests__/global.setup.ts

@@ -5,6 +5,12 @@ import {
 } from 'sanity';
 import { vi } from 'vitest';
 
+// jsdom doesn't provide window.CSS; sanity's form components call
+// CSS.supports at module scope when imported.
+if (typeof globalThis.CSS === 'undefined') {
+  (globalThis as { CSS?: unknown }).CSS = { supports: () => false };
+}
+
 let mockTestKey = 0;
 
 vi.mock('@portabletext/block-tools', async () => {

package/src/serialization/__tests__/helpers.ts

@@ -1,4 +1,5 @@
-import { BaseDocumentSerializer, BaseDocumentDeserializer } from '../index';
+import { BaseDocumentSerializer } from '../serialize/index';
+import { BaseDocumentDeserializer } from '../deserialize/BaseDocumentDeserializer';
 import {
   customSerializers,
   customDeserializers,

package/src/serialization/internationalizedArray/__tests__/internationalizedArray.test.ts

@@ -0,0 +1,265 @@
+import { describe, expect, test } from 'vitest';
+import {
+  findLocaleItem,
+  isInternationalizedArrayField,
+  isInternationalizedArrayItem,
+} from '../detect';
+import { collapseToSourceLocale } from '../collapse';
+import { mergeInternationalizedArrays } from '../merge';
+import { pluginConfig } from '../../../adapter/core';
+
+const stringItem = (language: string, value: string) => ({
+  _key: `key-${language}`,
+  _type: 'internationalizedArrayStringValue',
+  language,
+  value,
+});
+
+describe('detect', () => {
+  test('recognises an internationalized array item by shape', () => {
+    expect(isInternationalizedArrayItem(stringItem('en', 'Hello'))).toBe(true);
+  });
+
+  test('rejects plain objects and ordinary array entries', () => {
+    expect(isInternationalizedArrayItem({ _type: 'block', children: [] })).toBe(
+      false
+    );
+    expect(isInternationalizedArrayItem({ language: 'en', value: 'x' })).toBe(
+      false
+    );
+  });
+
+  test('rejects user-defined *Value types that only share the shape', () => {
+    expect(
+      isInternationalizedArrayItem({
+        _key: 'k',
+        _type: 'priceValue',
+        language: 'USD',
+        value: 9.99,
+      })
+    ).toBe(false);
+  });
+
+  test('recognises items generated with a custom typePrefix', () => {
+    const item = {
+      _key: 'k',
+      _type: 'myI18nStringValue',
+      language: 'en',
+      value: 'Hello',
+    };
+    expect(isInternationalizedArrayItem(item)).toBe(false);
+
+    const originalPrefix = pluginConfig.fieldLevelTypePrefix;
+    pluginConfig.fieldLevelTypePrefix = 'myI18n';
+    try {
+      expect(isInternationalizedArrayItem(item)).toBe(true);
+    } finally {
+      pluginConfig.fieldLevelTypePrefix = originalPrefix;
+    }
+  });
+
+  test('recognises a full internationalized array field', () => {
+    const field = [stringItem('en', 'Hello'), stringItem('es', 'Hola')];
+    expect(isInternationalizedArrayField(field)).toBe(true);
+  });
+
+  test('a mixed/ordinary array is not an internationalized array field', () => {
+    expect(isInternationalizedArrayField([{ _type: 'block' }])).toBe(false);
+    expect(isInternationalizedArrayField([])).toBe(false);
+  });
+
+  test('findLocaleItem matches on exact language id, not _key', () => {
+    const field = [stringItem('en', 'Hello'), stringItem('fr-CA', 'Bonjour')];
+    expect(findLocaleItem(field, 'fr-CA')?.value).toBe('Bonjour');
+    expect(findLocaleItem(field, 'key-en')).toBeUndefined();
+  });
+});
+
+describe('collapseToSourceLocale', () => {
+  test('exports only the source-locale value for a string field', () => {
+    const doc = {
+      _id: 'a',
+      _type: 'post',
+      title: [stringItem('en', 'Hello'), stringItem('es', 'Hola')],
+    };
+    expect(collapseToSourceLocale(doc, 'en')).toEqual({
+      _id: 'a',
+      _type: 'post',
+      title: 'Hello',
+    });
+  });
+
+  test('skips a field with no source-locale item', () => {
+    const doc = {
+      _type: 'post',
+      title: [stringItem('es', 'Hola'), stringItem('fr', 'Bonjour')],
+    };
+    expect(collapseToSourceLocale(doc, 'en')).toEqual({ _type: 'post' });
+  });
+
+  test('handles hyphenated source locale ids', () => {
+    const doc = {
+      _type: 'post',
+      title: [stringItem('en-US', 'Hello'), stringItem('es', 'Hola')],
+    };
+    expect(collapseToSourceLocale(doc, 'en-US')).toEqual({
+      _type: 'post',
+      title: 'Hello',
+    });
+  });
+
+  test('preserves Portable Text source values', () => {
+    const blocks = [{ _type: 'block', _key: 'b1', children: [] }];
+    const doc = {
+      _type: 'post',
+      body: [
+        {
+          _key: 'k',
+          _type: 'internationalizedArrayBlockValue',
+          language: 'en',
+          value: blocks,
+        },
+      ],
+    };
+    expect(collapseToSourceLocale(doc, 'en')).toEqual({
+      _type: 'post',
+      body: blocks,
+    });
+  });
+
+  test('leaves ordinary (non-localized) arrays untouched', () => {
+    const doc = { _type: 'post', tags: ['a', 'b'] };
+    expect(collapseToSourceLocale(doc, 'en')).toEqual(doc);
+  });
+
+  test('handles an internationalized array field nested inside an object', () => {
+    const doc = {
+      _type: 'post',
+      seo: {
+        _type: 'seo',
+        heading: [stringItem('en', 'Hi'), stringItem('es', 'Hola')],
+      },
+    };
+    expect(collapseToSourceLocale(doc, 'en')).toEqual({
+      _type: 'post',
+      seo: { _type: 'seo', heading: 'Hi' },
+    });
+  });
+});
+
+describe('mergeInternationalizedArrays', () => {
+  test('updates an existing target-locale item, preserving its _key', () => {
+    const baseDoc = {
+      _id: 'a',
+      _type: 'post',
+      title: [stringItem('en', 'Hello'), stringItem('es', 'OLD')],
+    };
+    const changes = mergeInternationalizedArrays(
+      baseDoc,
+      { _type: 'post', title: 'Hola' },
+      'es',
+      'en'
+    );
+    expect(changes.title).toEqual([
+      stringItem('en', 'Hello'),
+      stringItem('es', 'Hola'),
+    ]);
+  });
+
+  test('inserts a missing target-locale item with a fresh random _key', () => {
+    const baseDoc = {
+      _type: 'post',
+      title: [stringItem('en', 'Hello')],
+    };
+    const changes = mergeInternationalizedArrays(
+      baseDoc,
+      { _type: 'post', title: 'Bonjour' },
+      'fr',
+      'en'
+    );
+    const title = changes.title as Array<Record<string, unknown>>;
+    expect(title).toHaveLength(2);
+    const inserted = title[1];
+    expect(inserted.language).toBe('fr');
+    expect(inserted.value).toBe('Bonjour');
+    expect(inserted._type).toBe('internationalizedArrayStringValue');
+    expect(typeof inserted._key).toBe('string');
+    expect(inserted._key).not.toBe('key-en');
+  });
+
+  test('preserves the source-locale item', () => {
+    const baseDoc = {
+      _type: 'post',
+      title: [stringItem('en', 'Hello')],
+    };
+    const changes = mergeInternationalizedArrays(
+      baseDoc,
+      { _type: 'post', title: 'Hola' },
+      'es',
+      'en'
+    );
+    const title = changes.title as Array<Record<string, unknown>>;
+    expect(title.find((i) => i.language === 'en')?.value).toBe('Hello');
+  });
+
+  test('leaves non-translatable sibling fields out of the patch', () => {
+    const baseDoc = {
+      _type: 'post',
+      title: [stringItem('en', 'Hello')],
+      slug: { current: 'hello' },
+    };
+    const changes = mergeInternationalizedArrays(
+      baseDoc,
+      { _type: 'post', title: 'Hola', slug: { current: 'hola' } },
+      'es',
+      'en'
+    );
+    expect(Object.keys(changes)).toEqual(['title']);
+  });
+
+  test('handles hyphenated target locale ids', () => {
+    const baseDoc = {
+      _type: 'post',
+      title: [stringItem('en', 'Hello')],
+    };
+    const changes = mergeInternationalizedArrays(
+      baseDoc,
+      { _type: 'post', title: 'Bonjour' },
+      'fr-CA',
+      'en'
+    );
+    const title = changes.title as Array<Record<string, unknown>>;
+    expect(title.find((i) => i.language === 'fr-CA')?.value).toBe('Bonjour');
+  });
+
+  test('upserts an internationalized array nested inside an object field', () => {
+    const baseDoc = {
+      _type: 'post',
+      seo: {
+        _type: 'seo',
+        _key: undefined,
+        heading: [stringItem('en', 'Hi')],
+      },
+    };
+    const changes = mergeInternationalizedArrays(
+      baseDoc,
+      { _type: 'post', seo: { _type: 'seo', heading: 'Hola' } },
+      'es',
+      'en'
+    );
+    const seo = changes.seo as { heading: Array<Record<string, unknown>> };
+    expect(seo.heading.find((i) => i.language === 'es')?.value).toBe('Hola');
+    expect(seo.heading.find((i) => i.language === 'en')?.value).toBe('Hi');
+  });
+
+  test('returns no changes when there is no localized content', () => {
+    const baseDoc = { _type: 'post', title: 'plain' };
+    const changes = mergeInternationalizedArrays(
+      baseDoc,
+      { _type: 'post', title: 'plain-es' },
+      'es',
+      'en'
+    );
+    expect(changes).toEqual({});
+  });
+});