sanity-plugin-taxonomy-manager 4.7.2 → 5.0.0

package/src/skosConcept.tsx

@@ -1,38 +1,19 @@
-import {WarningOutlineIcon} from '@sanity/icons'
-import {DocumentId, getPublishedId} from '@sanity/id-utils'
 import {AiOutlineTag, AiOutlineTags} from 'react-icons/ai'
 import {defineType, defineField} from 'sanity'
-import type {SanityDocument} from 'sanity'
 
 import {Identifier} from './components/inputs'
+import {createId} from './core/createId'
+import {conceptFilter, prefLabelUniquenessResult} from './core/validation'
 import baseIriField from './helpers/baseIriField'
-import {createId} from './helpers/createId'
-import styles from './skosConcept.module.css'
 import type {Options} from './types'
 
-const conceptFilter = ({document}: {document: SanityDocument}) => {
-  const publishedId = getPublishedId(DocumentId(document._id))
-  return {
-    filter: '!(_id in $broader || _id in $related || _id == $self)',
-    params: {
-      self: publishedId,
-      broader: Array.isArray(document?.broader)
-        ? document.broader.map(({_ref}: {_ref: string}) => _ref)
-        : [],
-      related: Array.isArray(document?.related)
-        ? document.related.map(({_ref}: {_ref: string}) => _ref)
-        : [],
-    },
-  }
-}
-
 /**
  * Sanity document scheme for SKOS Taxonomy Concepts
  */
 export default function skosConcept(
   baseUri?: Options['baseUri'],
   customConceptFields: Options['customConceptFields'] = [],
-  ident?: Options['ident']
+  ident?: Options['ident'],
 ) {
   return defineType({
     name: 'skosConcept',
@@ -73,125 +54,40 @@ export default function skosConcept(
               .fetch(
                 `*[_type == "skosConcept" && prefLabel == "${
                   prefLabel as string
-                }" && !(_id in path("drafts.**") || _id in path("versions.**"))][0]._id`
+                }" && !(_id in path("drafts.**") || _id in path("versions.**"))][0]._id`,
+              )
+              .then((conceptId) =>
+                prefLabelUniquenessResult(conceptId as string | null, context.document?._id),
               )
-              .then((conceptId) => {
-                if (conceptId && !context.document?._id.includes(conceptId as string)) {
-                  return 'Preferred Label must be unique.'
-                }
-                return true
-              })
           }),
       }),
       defineField({
         name: 'definition',
         title: 'Definition',
         type: 'text',
-        description: (
-          <details className={styles.description}>
-            <summary>A complete explanation of the intended meaning of the concept.</summary>
-            <div>
-              <kbd>
-                Example: documentation
-                <br />
-                Definition: "The process of storing and retrieving information in all fields of
-                knowledge."
-              </kbd>
-              <p>
-                For more information on the recommended usage of the SKOS documentation properties,
-                see
-                <a
-                  href="https://www.w3.org/TR/2009/NOTE-skos-primer-20090818/#secdocumentation"
-                  target="_blank"
-                  rel="noreferrer"
-                >
-                  {' '}
-                  W3C SKOS Primer: 2.4 Documentary Notes
-                </a>
-              </p>
-            </div>
-          </details>
-        ),
+        description: 'A complete explanation of the intended meaning of the concept.',
         rows: 3,
       }),
       defineField({
         name: 'example',
         title: 'Examples',
         type: 'text',
-        description: (
-          <details className={styles.description}>
-            <summary>An example of the use of the concept.</summary>
-            <div>
-              <kbd>
-                Example: organizations of science and culture
-                <br />
-                Example: "academies of science, general museums, world fairs"
-              </kbd>
-              <p>
-                For more information on the recommended usage of the SKOS documentation properties,
-                see
-                <a
-                  href="https://www.w3.org/TR/2009/NOTE-skos-primer-20090818/#secdocumentation"
-                  target="_blank"
-                  rel="noreferrer"
-                >
-                  {' '}
-                  W3C SKOS Primer: 2.4 Documentary Notes
-                </a>
-              </p>
-            </div>
-          </details>
-        ),
+        description: 'An example of the use of the concept.',
         rows: 3,
       }),
       defineField({
         name: 'scopeNote',
         title: 'Scope Note',
         type: 'text',
-        description: (
-          <details className={styles.description}>
-            <summary>
-              A brief statement on the intended meaning of this concept, especially as an indication
-              of how the use of the concept is limited in indexing practice.
-            </summary>
-            <div>
-              <kbd>
-                Example: microwave frequencies
-                <br />
-                Scope Note: "Used for frequencies between 1Ghz and 300Ghz"
-              </kbd>
-              <p>
-                For more information on the recommended usage of the SKOS documentation properties,
-                see
-                <a
-                  href="https://www.w3.org/TR/2009/NOTE-skos-primer-20090818/#secdocumentation"
-                  target="_blank"
-                  rel="noreferrer"
-                >
-                  {' '}
-                  W3C SKOS Primer: 2.4 Documentary Notes
-                </a>
-              </p>
-            </div>
-          </details>
-        ),
+        description:
+          'A brief statement on the intended meaning of this concept, especially as an indication of how the use of the concept is limited in indexing practice.',
         rows: 3,
       }),
       defineField({
         name: 'altLabel',
         title: 'Alternate Label(s)',
         type: 'array',
-        description: (
-          <details className={styles.description}>
-            <summary>Synonyms, near-synonyms, abbreviations, and acronyms to a concept.</summary>
-            <div>
-              <p>
-                <WarningOutlineIcon /> Preferred, alternative, and hidden label sets must not
-                overlap.
-              </p>
-            </div>
-          </details>
-        ),
+        description: 'Synonyms, near-synonyms, abbreviations, and acronyms to a concept.',
         of: [{type: 'string'}],
         validation: (Rule) => Rule.unique(),
       }),
@@ -199,24 +95,8 @@ export default function skosConcept(
         name: 'hiddenLabel',
         title: 'Hidden Label(s)',
         type: 'array',
-        description: (
-          <details className={styles.description}>
-            <summary>
-              Character strings that need to be accessible to applications performing text-based
-              indexing and search operations, but which should not be displayed to end users.
-            </summary>
-            <div>
-              <p>
-                Hidden labels may for instance be used to include misspelled variants of other
-                lexical labels.
-              </p>
-              <p>
-                <WarningOutlineIcon /> Preferred, alternative, and hidden label sets must not
-                overlap.
-              </p>
-            </div>
-          </details>
-        ),
+        description:
+          'Character strings that need to be accessible to applications performing text-based indexing and search operations, but which should not be displayed to end users.',
         of: [{type: 'string'}],
         validation: (Rule) => Rule.unique(),
       }),
@@ -237,17 +117,8 @@ export default function skosConcept(
       defineField({
         name: 'broader',
         title: 'Broader Concept(s)',
-        description: (
-          <details className={styles.description}>
-            <summary>
-              Create hierarchy between concepts, for example to create category/subcategory,
-              part/whole, or class/instance relationships.
-            </summary>
-            <div>
-              <p>Broader and Associated relationships are mutually exclusive.</p>
-            </div>
-          </details>
-        ),
+        description:
+          'Create hierarchy between concepts, for example to create category/subcategory, part/whole, or class/instance relationships.',
         type: 'array',
         of: [
           {
@@ -262,17 +133,8 @@ export default function skosConcept(
       defineField({
         name: 'related',
         title: 'Related Concept(s)',
-        description: (
-          <details className={styles.description}>
-            <summary>
-              Indicate that two concepts are inherently "related", but that one is not in any way
-              more general than the other.
-            </summary>
-            <div>
-              <p>Broader and Associated relationships are mutually exclusive.</p>
-            </div>
-          </details>
-        ),
+        description:
+          'Indicate that two concepts are inherently "related", but that one is not in any way more general than the other.',
         type: 'array',
         of: [
           {
@@ -289,96 +151,23 @@ export default function skosConcept(
         name: 'historyNote',
         title: 'History Notes',
         type: 'text',
-        description: (
-          <details className={styles.description}>
-            <summary>Significant changes to the meaning or the form of this concept.</summary>
-            <div>
-              <kbd>
-                Example: person with disabilities
-                <br />
-                History Note: "Estab. 1992; heading was: handicapped [1884 - 1992]."
-              </kbd>
-              <p>
-                For more information on the recommended usage of the SKOS documentation properties,
-                see
-                <a
-                  href="https://www.w3.org/TR/2009/NOTE-skos-primer-20090818/#secdocumentation"
-                  target="_blank"
-                  rel="noreferrer"
-                >
-                  {' '}
-                  W3C SKOS Primer: 2.4 Documentary Notes
-                </a>
-              </p>
-            </div>
-          </details>
-        ),
+        description: 'Significant changes to the meaning or the form of this concept.',
         rows: 3,
       }),
       defineField({
         name: 'editorialNote',
         title: 'Editorial Notes',
         type: 'text',
-        description: (
-          <details className={styles.description}>
-            <summary>
-              Information to aid in administrative housekeeping, such as reminders of editorial work
-              still to be done, or warnings in the event that future editorial changes might be
-              made.
-            </summary>
-            <div>
-              <kbd>
-                Example: doubleclick
-                <br />
-                Editorial Note: "Review this term after the company merger is complete."
-              </kbd>
-              <p>
-                For more information on the recommended usage of the SKOS documentation properties,
-                see
-                <a
-                  href="https://www.w3.org/TR/2009/NOTE-skos-primer-20090818/#secdocumentation"
-                  target="_blank"
-                  rel="noreferrer"
-                >
-                  {' '}
-                  W3C SKOS Primer: 2.4 Documentary Notes
-                </a>
-              </p>
-            </div>
-          </details>
-        ),
+        description:
+          'Information to aid in administrative housekeeping, such as reminders of editorial work still to be done, or warnings in the event that future editorial changes might be made.',
         rows: 3,
       }),
       defineField({
         name: 'changeNote',
         title: 'Change Notes',
         type: 'text',
-        description: (
-          <details className={styles.description}>
-            <summary>
-              Fine-grained changes to a concept, for the purposes of administration and maintenance.
-            </summary>
-            <div>
-              <kbd>
-                Example: tomato
-                <br />
-                Change Note: "Moved from under 'fruits' to under 'vegetables' by Horace Gray"
-              </kbd>
-              <p>
-                For more information on the recommended usage of the SKOS documentation properties,
-                see
-                <a
-                  href="https://www.w3.org/TR/2009/NOTE-skos-primer-20090818/#secdocumentation"
-                  target="_blank"
-                  rel="noreferrer"
-                >
-                  {' '}
-                  W3C SKOS Primer: 2.4 Documentary Notes
-                </a>
-              </p>
-            </div>
-          </details>
-        ),
+        description:
+          'Fine-grained changes to a concept, for the purposes of administration and maintenance.',
         rows: 3,
       }),
     ],

package/src/skosConceptScheme.tsx

@@ -1,10 +1,8 @@
-// import {nanoid} from 'nanoid'
-// import type {FieldDefinition} from 'sanity'
 import {defineArrayMember, defineField, defineType} from 'sanity'
 
 import {Identifier, ManagementControls} from './components/inputs'
 import baseIriField from './helpers/baseIriField'
-import {createId} from './helpers/createId'
+import {createId} from './core/createId'
 import NodeTree from './static/NodeTree'
 import type {Options} from './types'
 
@@ -14,7 +12,7 @@ import type {Options} from './types'
 export default function skosConceptScheme(
   baseUri?: Options['baseUri'],
   customSchemeFields: Options['customSchemeFields'] = [],
-  ident?: Options['ident']
+  ident?: Options['ident'],
 ) {
   return defineType({
     name: 'skosConceptScheme',

package/src/structure.tsx

@@ -0,0 +1,60 @@
+import {EditIcon, DocumentsIcon} from '@sanity/icons'
+import type {StructureBuilder, ListBuilder, DefaultDocumentNodeResolver} from 'sanity/structure'
+
+import {TreeView} from './components/TreeView'
+import {TaxonomyConfigContext} from './context'
+import NodeTree from './static/NodeTree'
+import type {Options, TreeViewProps} from './types'
+import {ConceptUseView} from './views/ConceptUseView'
+
+/**
+ * #### Default Desk Structure for Concept and Concept Scheme
+ * Sets defaultDocumentNode. Consider exporting in the future,
+ * if there is a use case for mixing taxonomy views in the main
+ * desk structure.
+ */
+export const structure = (S: StructureBuilder): ListBuilder =>
+  S.list()
+    .title('Taxonomy Manager')
+    .items([
+      S.documentTypeListItem('skosConceptScheme').title('Concept Schemes'),
+      S.documentTypeListItem('skosConcept').title('Concepts'),
+    ])
+
+/**
+ * #### Default Document Node (factory)
+ * Builds the `defaultDocumentNode` resolver, closing over plugin config so the
+ * structure Tree View can read `ident` from React context — replacing the old
+ * `config.ts` `getPluginConfig` singleton. Called once at plugin init, so the
+ * wrapper component identity stays stable across resolver invocations.
+ */
+export const createDefaultDocumentNode = (
+  config: {ident?: Options['ident']} = {}
+): DefaultDocumentNodeResolver => {
+  // Provide plugin config to the structure Tree View subtree (the only place
+  // concept creation reads `ident`). Input-component trees render without this
+  // provider and fall back to the context default — they never create concepts.
+  const TreeViewWithConfig = (props: TreeViewProps) => (
+    <TaxonomyConfigContext.Provider value={{ident: config.ident}}>
+      <TreeView {...props} />
+    </TaxonomyConfigContext.Provider>
+  )
+
+  return (S, {schemaType}) => {
+    // Conditionally return a different configuration based on the schema type
+    switch (schemaType) {
+      case 'skosConceptScheme':
+        return S.document().views([
+          S.view.component(TreeViewWithConfig).title('Tree View').icon(NodeTree),
+          S.view.form().icon(EditIcon),
+        ])
+      case 'skosConcept':
+        return S.document().views([
+          S.view.form().icon(EditIcon),
+          S.view.component(ConceptUseView).title('Tagged Resources').icon(DocumentsIcon),
+        ])
+      default:
+        return S.document().views([S.view.form().icon(EditIcon)])
+    }
+  }
+}

package/src/test/FakeDataPort.test.ts

@@ -0,0 +1,62 @@
+import {renderHook} from '@testing-library/react'
+import {describe, expect, it} from 'vitest'
+
+import {planCreateConcept} from '../core/mutations'
+import type {ConceptSchemeDocument, DocumentConcepts} from '../types'
+
+import {createFakeDataPort} from './FakeDataPort'
+
+const scheme = {_id: 'scheme-1', _type: 'skosConceptScheme'} as ConceptSchemeDocument['displayed']
+const TREE: DocumentConcepts = {topConcepts: [], concepts: []}
+
+describe('createFakeDataPort', () => {
+  it('useWatchTree returns the configured fixture synchronously and records params', () => {
+    const port = createFakeDataPort({tree: TREE})
+    const params = {mode: 'trunk', documentId: 'scheme-1', perspective: undefined} as const
+
+    const {result} = renderHook(() => port.useWatchTree(params))
+
+    expect(result.current).toEqual({data: TREE, loading: false, error: null})
+    expect(port.lastWatchParams).toEqual(params)
+  })
+
+  it('defaults to a null, non-loading, error-free result', () => {
+    const port = createFakeDataPort()
+    const {result} = renderHook(() =>
+      port.useWatchTree({mode: 'trunk', documentId: 's', perspective: undefined})
+    )
+    expect(result.current).toEqual({data: null, loading: false, error: null})
+  })
+
+  it('useApplyConceptPlan records each plan it is given, in order', async () => {
+    const port = createFakeDataPort()
+    const plan = planCreateConcept({
+      scheme,
+      conceptType: 'topConcept',
+      newConceptUuid: 'u',
+      conceptId: 'abc123',
+      schemeBaseIri: undefined,
+      newConceptKey: 'k',
+      broaderKey: 'b',
+    })
+
+    const {result} = renderHook(() => port.useApplyConceptPlan())
+    await result.current(plan)
+
+    expect(port.appliedPlans).toEqual([plan])
+  })
+
+  it('useSemanticRecommendations returns configured recs and counts search triggers', () => {
+    const port = createFakeDataPort({
+      recommendations: [{conceptId: 'd1', score: 0.9}],
+    })
+
+    const {result} = renderHook(() => port.useSemanticRecommendations())
+    expect(result.current.conceptRecs).toHaveLength(1)
+    expect(result.current.recsError).toBeNull()
+
+    result.current.triggerSearch('scheme-7')
+    expect(port.triggeredSearches).toBe(1)
+    expect(port.lastSearchSchemeId).toBe('scheme-7')
+  })
+})

package/src/test/FakeDataPort.ts

@@ -0,0 +1,69 @@
+import type {
+  ConceptPlan,
+  ConceptTreeParams,
+  SemanticRecommendationsResult,
+  TaxonomyDataPort,
+  WatchResult,
+} from '../core/ports'
+import type {ConceptRecommendation, DocumentConcepts} from '../types'
+
+/** Fixtures + canned responses for a {@link createFakeDataPort}. */
+export interface FakeDataPortConfig {
+  tree?: DocumentConcepts | null
+  loading?: boolean
+  error?: Error | null
+  recommendations?: ConceptRecommendation[]
+  recsError?: string | null
+}
+
+/** A {@link TaxonomyDataPort} that also exposes recorded interactions for assertions. */
+export interface FakeDataPort extends TaxonomyDataPort {
+  /** Plans passed to the applyConceptPlan function, in call order. */
+  readonly appliedPlans: ConceptPlan[]
+  /** Number of `triggerSearch()` calls. */
+  triggeredSearches: number
+  /** The `schemeId` passed to the most recent `triggerSearch()` call. */
+  lastSearchSchemeId: string | undefined
+  /** Params from the most recent `useWatchTree` call. */
+  lastWatchParams: ConceptTreeParams | null
+}
+
+/**
+ * In-memory `TaxonomyDataPort` for component/tree tests. Returns the configured
+ * fixtures synchronously (no Studio, no network) and records mutations and
+ * search triggers for assertions. The hook members call no React hooks, so they
+ * return stable references and never suspend. Provide via:
+ * `<TaxonomyPortProvider port={createFakeDataPort({tree})}>`.
+ */
+export function createFakeDataPort(config: FakeDataPortConfig = {}): FakeDataPort {
+  const watchResult: WatchResult<DocumentConcepts> = {
+    data: config.tree ?? null,
+    loading: config.loading ?? false,
+    error: config.error ?? null,
+  }
+  const recsResult: SemanticRecommendationsResult = {
+    conceptRecs: config.recommendations ?? [],
+    recsError: config.recsError ?? null,
+    triggerSearch: (schemeId?: string) => {
+      fake.triggeredSearches += 1
+      fake.lastSearchSchemeId = schemeId
+    },
+  }
+  const apply = (plan: ConceptPlan): Promise<void> => {
+    fake.appliedPlans.push(plan)
+    return Promise.resolve()
+  }
+  const fake: FakeDataPort = {
+    appliedPlans: [],
+    triggeredSearches: 0,
+    lastSearchSchemeId: undefined,
+    lastWatchParams: null,
+    useWatchTree: (params: ConceptTreeParams) => {
+      fake.lastWatchParams = params
+      return watchResult
+    },
+    useApplyConceptPlan: () => apply,
+    useSemanticRecommendations: () => recsResult,
+  }
+  return fake
+}

package/src/test/inputHarness.tsx

@@ -0,0 +1,71 @@
+import {vi} from 'vitest'
+
+import type {ArrayHierarchyInput} from '../components/inputs/ArrayHierarchyInput'
+import type {ReferenceHierarchyInput} from '../components/inputs/ReferenceHierarchyInput'
+
+/**
+ * Shared fixtures for the input-component jsdom tests. The components read Studio
+ * primitives (`useClient`/`useFormValue`/`usePerspective`, `FormField`) that each
+ * test file stubs via `vi.mock('sanity', …)`; this module supplies the bulky,
+ * mock-independent pieces: a chainable client stub and field-props factories.
+ */
+
+/** A Studio client stub that resolves the scheme lookup and no-ops mutations. */
+export function fakeSchemeClient(
+  scheme: Record<string, unknown> = {_id: 'scheme-x', _type: 'skosConceptScheme', title: 'Test Scheme'}
+) {
+  const client: Record<string, unknown> = {
+    withConfig: () => client,
+    fetch: vi.fn().mockResolvedValue({displayed: scheme}),
+    patch: vi.fn(() => client),
+    set: vi.fn(() => client),
+    setIfMissing: vi.fn(() => client),
+    append: vi.fn(() => client),
+    commit: vi.fn().mockResolvedValue(undefined),
+    create: vi.fn().mockResolvedValue(undefined),
+    transaction: vi.fn(() => client),
+  }
+  return client as unknown as ReturnType<typeof import('sanity').useClient>
+}
+
+/**
+ * A resolved field filter. Real `schemeFilter()`/`branchFilter()` resolve to a
+ * single-argument function; the components treat a zero-arity filter as
+ * misconfigured (`filter.length === 0`), so this keeps arity 1.
+ */
+export const filterFor =
+  (params: Record<string, unknown>, extra: Record<string, unknown> = {}) =>
+  (_opts: unknown) =>
+    Promise.resolve({filter: 'scheme-filter', params, ...extra})
+
+const sharedProps = {
+  level: 0,
+  value: undefined,
+  validation: [],
+  presence: [],
+  renderDefault: () => <div data-testid="default-input">default input</div>,
+}
+
+/** Minimal `ReferenceHierarchyInput` props; `renderDefault` renders a recognizable marker. */
+export function referenceFieldProps(overrides: Record<string, unknown> = {}) {
+  return {
+    ...sharedProps,
+    name: 'subject',
+    title: 'Subject',
+    path: ['subject'],
+    schemaType: {options: {filter: filterFor({schemeId: 'scheme-x'})}},
+    ...overrides,
+  } as unknown as Parameters<typeof ReferenceHierarchyInput>[0]
+}
+
+/** Minimal `ArrayHierarchyInput` props; the filter lives on `of[0].options`. */
+export function arrayFieldProps(overrides: Record<string, unknown> = {}) {
+  return {
+    ...sharedProps,
+    name: 'topics',
+    title: 'Topics',
+    path: ['topics'],
+    schemaType: {of: [{options: {filter: filterFor({schemeId: 'scheme-x'})}}]},
+    ...overrides,
+  } as unknown as Parameters<typeof ArrayHierarchyInput>[0]
+}

package/src/test/renderWithUi.test.tsx

@@ -0,0 +1,14 @@
+import {Text} from '@sanity/ui'
+import {screen} from '@testing-library/react'
+import {describe, expect, it} from 'vitest'
+
+import {renderWithUi} from './renderWithUi'
+
+// Smoke test for the whole harness: vitest + jsdom + esbuild JSX +
+// test-setup (matchMedia/jest-dom) + the @sanity/ui provider stack.
+describe('test harness', () => {
+  it('renders a @sanity/ui component inside the provider stack', () => {
+    renderWithUi(<Text>taxonomy harness ok</Text>)
+    expect(screen.getByText('taxonomy harness ok')).toBeInTheDocument()
+  })
+})

package/src/test/renderWithUi.tsx

@@ -0,0 +1,24 @@
+import {LayerProvider, ThemeProvider, ToastProvider} from '@sanity/ui'
+import {buildTheme} from '@sanity/ui/theme'
+import {render, type RenderResult} from '@testing-library/react'
+import type {ReactElement, ReactNode} from 'react'
+
+const theme = buildTheme()
+
+/**
+ * Render a component inside the @sanity/ui provider stack (theme, layers,
+ * toasts) so Studio UI primitives — popovers, portals, toasts — behave as they
+ * do in the Studio, without booting a full Studio. Used by component
+ * interaction tests.
+ */
+export function renderWithUi(ui: ReactElement): RenderResult {
+  return render(ui, {
+    wrapper: ({children}: {children: ReactNode}) => (
+      <ThemeProvider theme={theme}>
+        <LayerProvider>
+          <ToastProvider>{children}</ToastProvider>
+        </LayerProvider>
+      </ThemeProvider>
+    ),
+  })
+}