@sanity/language-filter 4.1.0 → 5.0.1

package/src/plugin.tsx

@@ -1,86 +0,0 @@
-import {
-  definePlugin,
-  type DocumentLanguageFilterComponent,
-  isObjectSchemaType,
-  type ObjectInputProps,
-} from 'sanity'
-
-import {isLanguageFilterEnabled} from './filterField'
-import {LanguageFilterMenuButton} from './LanguageFilterMenuButton'
-import {FilteredObjectWrapper} from './LanguageFilterObjectInput'
-import {defaultContextValue, LanguageFilterStudioProvider} from './LanguageFilterStudioContext'
-import type {LanguageFilterConfig} from './types'
-
-/**
- * ## Usage in sanity.config.ts (or .js)
- *
- * ```
- * import {defineConfig} from 'sanity'
- * import {languageFilter} from '@sanity/language-filter'
- *
- * export const defineConfig({
- *     /...
- *     plugins: [
- *         languageFilter({
- *             supportedLanguages: [
- *               {id: 'nb', title: 'Norwegian (Bokmål)'},
- *               {id: 'nn', title: 'Norwegian (Nynorsk)'},
- *               {id: 'en', title: 'English'},
- *               {id: 'es', title: 'Spanish'},
- *               {id: 'arb', title: 'Arabic'},
- *               {id: 'pt', title: 'Portuguese'},
- *               //...
- *             ],
- *             // Select Norwegian (Bokmål) by default
- *             defaultLanguages: ['nb'],
- *             // Only show language filter for document type `page` (schemaType.name)
- *             // Can also enable via document-options: options.languageFilter: true
- *             documentTypes: ['page'],
- *             // default filter function shown
- *             filterField: (enclosingType, field, selectedLanguageIds) =>
- *               !enclosingType.name.startsWith('locale') || selectedLanguageIds.includes(field.name),
- *        })
- *    ]
- * })
- * ```
- */
-export const languageFilter = definePlugin<LanguageFilterConfig>((options) => {
-  const RenderLanguageFilter: DocumentLanguageFilterComponent = () => {
-    return <LanguageFilterMenuButton />
-  }
-
-  const pluginOptions = {
-    ...defaultContextValue.options,
-    ...options,
-  }
-
-  return {
-    name: '@sanity/language-filter',
-    studio: {
-      components: {
-        layout: (props) => LanguageFilterStudioProvider({...props, options: pluginOptions}),
-      },
-    },
-
-    document: {
-      unstable_languageFilter: (prev, {schemaType, schema}) => {
-        if (isLanguageFilterEnabled(schema.get(schemaType), options)) {
-          return [...prev, RenderLanguageFilter]
-        }
-        return prev
-      },
-    },
-
-    form: {
-      components: {
-        input: (props) => {
-          if (props.id !== 'root' && isObjectSchemaType(props.schemaType)) {
-            return FilteredObjectWrapper(props as ObjectInputProps)
-          }
-
-          return props.renderDefault(props)
-        },
-      },
-    },
-  }
-})

package/src/types.ts

@@ -1,42 +0,0 @@
-import type {FieldMember, FieldsetState, ObjectSchemaType, SanityClient} from 'sanity'
-
-export interface LanguageFilterOptions {
-  languageFilter?: boolean
-}
-
-export interface LanguageFilterSchema extends ObjectSchemaType {
-  options?: LanguageFilterOptions
-}
-
-export type Language = {
-  id: Intl.UnicodeBCP47LocaleIdentifier
-  title: string
-}
-
-export type LanguageCallback = (
-  client: SanityClient,
-  selectedValue: Record<string, unknown>,
-) => Promise<Language[]>
-
-export type FilterFieldFunction = (
-  enclosingType: ObjectSchemaType,
-  field: FieldMember | FieldsetState,
-  selectedLanguageIds: string[],
-  parentValue: Record<string, unknown> | undefined,
-) => boolean
-
-export interface LanguageFilterConfig {
-  supportedLanguages: Language[] | LanguageCallback
-  defaultLanguages?: string[]
-  documentTypes?: string[]
-  filterField?: FilterFieldFunction
-  /**
-   * https://www.sanity.io/docs/api-versioning
-   * @defaultValue '2022-11-27'
-   */
-  apiVersion?: string
-}
-
-export interface LanguageFilterConfigProcessed extends LanguageFilterConfig {
-  supportedLanguages: Language[]
-}

package/src/usePaneLanguages.ts

@@ -1,65 +0,0 @@
-import {useCallback, useMemo} from 'react'
-
-import {useLanguageFilterStudioContext} from './LanguageFilterStudioContext'
-import {getSelectableLanguages, persistLanguageIds} from './useSelectedLanguageIds'
-
-const unique = (arr: string[]) => Array.from(new Set(arr))
-
-export function usePaneLanguages(): {
-  activeLanguages: string[]
-  allSelected: boolean
-  selectAll: () => void
-  selectNone: () => void
-  toggleLanguage: (languageId: string) => void
-} {
-  const {selectedLanguageIds, setSelectedLanguageIds, options} = useLanguageFilterStudioContext()
-  const {defaultLanguages = []} = options
-
-  const selectableLanguages = useMemo(() => getSelectableLanguages(options), [options])
-
-  const updateSelectedIds = useCallback(
-    (ids: string[]) => {
-      setSelectedLanguageIds(unique([...defaultLanguages, ...ids]))
-      persistLanguageIds(unique([...defaultLanguages, ...ids]))
-    },
-    [defaultLanguages, setSelectedLanguageIds],
-  )
-
-  const selectAll = useCallback(
-    () => updateSelectedIds(selectableLanguages.map((l) => l.id)),
-    [updateSelectedIds, selectableLanguages],
-  )
-
-  const selectNone = useCallback(() => {
-    updateSelectedIds(defaultLanguages)
-  }, [defaultLanguages, updateSelectedIds])
-
-  const toggleLanguage = useCallback(
-    (languageId: string) => {
-      let lang = selectedLanguageIds
-
-      if (lang.includes(languageId)) {
-        lang = lang.filter((l) => l !== languageId)
-      } else {
-        lang = unique([...lang, languageId])
-      }
-
-      updateSelectedIds(lang)
-    },
-    [updateSelectedIds, selectedLanguageIds],
-  )
-
-  const activeLanguages = useMemo(
-    () => unique([...(defaultLanguages ?? []), ...selectedLanguageIds]),
-    [defaultLanguages, selectedLanguageIds],
-  )
-
-  return {
-    activeLanguages,
-    allSelected:
-      selectedLanguageIds.length === selectableLanguages.length + defaultLanguages.length,
-    selectAll,
-    selectNone,
-    toggleLanguage,
-  }
-}

package/src/useSelectedLanguageIds.ts

@@ -1,43 +0,0 @@
-import {useState} from 'react'
-
-import type {Language, LanguageFilterConfig} from './types'
-const storageKey = '@sanity/plugin/language-filter/selected-languages'
-
-export function getPersistedLanguageIds(options: LanguageFilterConfig): string[] {
-  const selectableLangs = getSelectableLanguages(options).map((l) => l.id)
-
-  let selected: string[] = selectableLangs
-  try {
-    const persistedValue = window.localStorage.getItem(storageKey)
-    if (persistedValue) {
-      selected = JSON.parse(persistedValue)
-    }
-  } catch (err) {} // eslint-disable-line no-empty
-
-  // constrain persisted/selected languages to the ones currently supported
-  selected = intersection(selected, selectableLangs)
-  return selected
-}
-
-export function persistLanguageIds(languageIds: string[]): void {
-  window.localStorage.setItem(storageKey, JSON.stringify(languageIds))
-}
-
-function intersection(array1: string[], array2: string[]) {
-  return array1.filter((value) => array2.includes(value))
-}
-
-export function getSelectableLanguages({
-  supportedLanguages,
-  defaultLanguages,
-}: LanguageFilterConfig): Language[] {
-  return Array.isArray(supportedLanguages)
-    ? supportedLanguages.filter((lang) => !defaultLanguages?.includes(lang.id))
-    : []
-}
-
-export function useSelectedLanguageIds(
-  options: LanguageFilterConfig,
-): [string[], (ids: string[]) => void] {
-  return useState(() => [...(options.defaultLanguages ?? []), ...getPersistedLanguageIds(options)])
-}

package/v2-incompatible.js

@@ -1,11 +0,0 @@
-const {showIncompatiblePluginDialog} = require('@sanity/incompatible-plugin')
-const {name, version, sanityExchangeUrl} = require('./package.json')
-
-export default showIncompatiblePluginDialog({
-  name: name,
-  versions: {
-    v3: version,
-    v2: '^2.35.0',
-  },
-  sanityExchangeUrl,
-})