sanity-plugin-taxonomy-manager 4.7.2 → 5.0.0

package/src/context.ts

@@ -1,6 +1,6 @@
 import {createContext} from 'react'
 
-import type {ConceptSchemeDocument} from './types'
+import type {ConceptSchemeDocument, Options} from './types'
 
 type TreeContextType = {
   globalVisibility?: {treeId: string; treeVisibility: 'open' | 'closed'}
@@ -8,18 +8,38 @@ type TreeContextType = {
   setEditControls?: (value: boolean) => void
 }
 
-export type ReleaseContextType = {
-  isPublished?: boolean
-  isInRelease: boolean
-  releaseName?: string
-  documentId: string
-  versionId?: string
-}
-
 export const SchemeContext = createContext<ConceptSchemeDocument | null>(null)
 export const TreeContext = createContext<TreeContextType>({editControls: false})
-// export const ReleaseContext = createContext<ReleaseContextType>({
-//   isInRelease: false,
-//   documentId: '',
-// })
-export const ReleaseContext = createContext<any>(undefined)
+
+/**
+ * The active perspective name from `usePerspective().selectedPerspectiveName`
+ * (provided by TreeView): `undefined` for the default drafts view, otherwise a
+ * release name or `'published'`. Drives perspective-aware queries and the gating
+ * of edit controls.
+ */
+export const ReleaseContext = createContext<string | undefined>(undefined)
+
+/**
+ * Plugin config the render tree needs at runtime. Provided around the structure
+ * Tree View (see `createDefaultDocumentNode`); replaces the old `config.ts`
+ * `getPluginConfig` singleton. Defaults to empty so input-component trees (which
+ * never create concepts) render correctly without a provider.
+ */
+export type TaxonomyConfig = {ident?: Options['ident']}
+export const TaxonomyConfigContext = createContext<TaxonomyConfig>({})
+
+/**
+ * Connects the deep remove actions to Hierarchy's optimistic-removal layer:
+ * removing a concept marks its id so the tree prunes it instantly, ahead of the
+ * live listener catching up (see Hierarchy + core/tree/pruneConcepts). Defaults
+ * to no-ops, so trees rendered without the provider — the input components,
+ * which never remove — behave normally.
+ */
+export type OptimisticTreeContextType = {
+  markRemoved: (id: string) => void
+  unmarkRemoved: (id: string) => void
+}
+export const OptimisticTreeContext = createContext<OptimisticTreeContextType>({
+  markRemoved: () => undefined,
+  unmarkRemoved: () => undefined,
+})

package/src/core/__snapshots__/queries.test.ts.snap

@@ -0,0 +1,386 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`inputBuilder > matches the characterized GROQ output 1`] = `
+"
+  select($branchId != null => 
+    *[_id == $id][0] {
+      _updatedAt,
+      "concepts": concepts[$branchId in @->broader[]->.conceptId]->|order(prefLabel) {
+        "id": _id,
+        "level": 0,
+        "isOrphan": true,
+        _originalId,
+        prefLabel,
+        definition,
+        example,
+        scopeNote,
+        "childConcepts": *[_id in ^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 1,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 2,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 3,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 4,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 5,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 6,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      
+    }
+    }
+    }
+    }
+    }
+    }
+      }
+    },
+    *[_id == $id][0] {
+      _updatedAt,
+      "topConcepts":topConcepts[]->|order(prefLabel){
+        "id": _id,
+        "level": 0,
+        _originalId,
+        prefLabel,
+        definition,
+        example,
+        scopeNote,
+        "childConcepts": *[_id in ^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 1,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 2,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 3,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 4,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 5,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 6,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      
+    }
+    }
+    }
+    }
+    }
+    }
+      }, 
+      "concepts": concepts[]->|order(prefLabel){
+        "id": _id,
+        "level": 0,
+        "isOrphan": 
+          coalesce(
+            !array::intersects(
+              broader[]._ref, (
+                coalesce(^.concepts[]._ref, []) + coalesce(^.topConcepts[]._ref, [])
+              )
+            ), 
+          true),
+        _originalId,
+        prefLabel,
+        definition,
+        example,
+        scopeNote,
+        "childConcepts": *[_id in ^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 1,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 2,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 3,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 4,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 5,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 6,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      
+    }
+    }
+    }
+    }
+    }
+    }
+      }
+    }
+  )"
+`;
+
+exports[`trunkBuilder > matches the characterized GROQ output 1`] = `
+"*[_id == $id][0] {
+    _updatedAt,
+    "topConcepts": topConcepts[]->|order(prefLabel) {
+      "id": _id,
+      "level": 0,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 1,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 2,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 3,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 4,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 5,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 6,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      
+    }
+    }
+    }
+    }
+    }
+    }
+    },
+    "concepts": concepts[]->|order(prefLabel) {
+      "id": _id,
+      "level": 0,
+      "isOrphan": 
+        coalesce(
+          !array::intersects(
+            broader[]._ref, (
+              coalesce(^.concepts[]._ref, []) + coalesce(^.topConcepts[]._ref, [])
+            )
+          ),
+        true),
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 1,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 2,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 3,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 4,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 5,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      "childConcepts": *[_id in ^.^.^.^.^.^.^.concepts[]._ref && ^._id in broader[]._ref]|order(prefLabel)
+     {
+      "id": _id,
+      "level": 6,
+      _originalId,
+      prefLabel,
+      definition,
+      example,
+      scopeNote,
+      
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+  }"
+`;

package/src/core/__snapshots__/semanticRecommendations.test.ts.snap

@@ -0,0 +1,10 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`recommendationsQuery > matches the characterized GROQ output 1`] = `
+"*[_type == "skosConcept" && _id in *[_type == "skosConceptScheme" && schemeId == $schemeId][0]{
+    "ids": coalesce(topConcepts[]._ref, []) + coalesce(concepts[]._ref, [])
+  }.ids] | score(text::semanticSimilarity($searchQuery)) | order(_score desc) [0...$maxResults] {
+    "conceptId": _id,
+    "score": _score
+  }"
+`;

package/src/core/createId.test.ts

@@ -0,0 +1,35 @@
+import {describe, expect, it} from 'vitest'
+
+import {createId} from './createId'
+
+const DEFAULT_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+
+// nanoid is non-deterministic, so these assert SHAPE (length, charset, prefix),
+// not exact values — pinning the configurable id format the plugin ships with.
+describe('createId', () => {
+  it('generates a 6-character id from the default alphabet', () => {
+    const id = createId()
+    expect(id).toHaveLength(6)
+    expect([...id].every((char) => DEFAULT_ALPHABET.includes(char))).toBe(true)
+  })
+
+  it('honors a custom length', () => {
+    expect(createId({length: 10})).toHaveLength(10)
+  })
+
+  it('honors a custom alphabet/pattern', () => {
+    const id = createId({pattern: 'abc'})
+    expect(id).toHaveLength(6)
+    expect(/^[abc]{6}$/.test(id)).toBe(true)
+  })
+
+  it('prepends a prefix on top of the generated length', () => {
+    const id = createId({prefix: 'Q', length: 5})
+    expect(id.startsWith('Q')).toBe(true)
+    expect(id).toHaveLength(6) // prefix (1) + 5 generated chars
+  })
+
+  it('produces a different id on each call', () => {
+    expect(createId()).not.toBe(createId())
+  })
+})

package/src/core/filters.test.ts

@@ -0,0 +1,64 @@
+import {describe, expect, it} from 'vitest'
+
+import {
+  assertBranchId,
+  assertSchemeId,
+  buildBranchFilterResult,
+  buildSchemeFilterResult,
+} from './filters'
+
+describe('assertSchemeId', () => {
+  it('throws on a missing or non-string scheme id', () => {
+    expect(() => assertSchemeId(undefined)).toThrow(
+      'Invalid or missing schemeId: scheme Id must be a string',
+    )
+    expect(() => assertSchemeId('')).toThrow('Invalid or missing schemeId')
+    expect(() => assertSchemeId(123)).toThrow('Invalid or missing schemeId')
+  })
+
+  it('accepts a valid scheme id', () => {
+    expect(() => assertSchemeId('abc123')).not.toThrow()
+  })
+})
+
+describe('assertBranchId', () => {
+  it('throws on a missing or non-string branch id', () => {
+    expect(() => assertBranchId(null)).toThrow(
+      'Invalid or missing branchId: branch Id must be a string',
+    )
+    expect(() => assertBranchId('')).toThrow('Invalid or missing branchId')
+  })
+
+  it('accepts a valid branch id', () => {
+    expect(() => assertBranchId('d4e5f6')).not.toThrow()
+  })
+})
+
+describe('buildSchemeFilterResult', () => {
+  it('assembles the filter, params, and option passthrough', () => {
+    const result = buildSchemeFilterResult({
+      schemeId: 'abc123',
+      concepts: ['c-a', 'c-b'],
+      topConcepts: ['t-1'],
+      expanded: true,
+      browseOnly: false,
+    })
+    expect(result.filter).toMatchInlineSnapshot(`
+      "(_id in $concepts
+                    || _id in $topConcepts)"
+    `)
+    expect(result.params).toEqual({concepts: ['c-a', 'c-b'], topConcepts: ['t-1'], schemeId: 'abc123'})
+    expect(result.expanded).toBe(true)
+    expect(result.browseOnly).toBe(false)
+  })
+})
+
+describe('buildBranchFilterResult', () => {
+  it('assembles the filter, params, and option passthrough', () => {
+    const result = buildBranchFilterResult({schemeId: 'abc123', branchId: 'd4e5f6', concepts: ['c-x']})
+    expect(result.filter).toMatchInlineSnapshot(`"_id in $concepts"`)
+    expect(result.params).toEqual({concepts: ['c-x'], schemeId: 'abc123', branchId: 'd4e5f6'})
+    expect(result.expanded).toBeUndefined()
+    expect(result.browseOnly).toBeUndefined()
+  })
+})

package/src/core/filters.ts

@@ -0,0 +1,68 @@
+/**
+ * Pure halves of the reference-field filters. The public `schemeFilter` /
+ * `branchFilter` factories (in ../helpers) keep the impure GROQ fetch; the
+ * validation and result-assembly below are pure and unit-tested here.
+ */
+
+export type SchemeFilterResult = {
+  filter: string
+  params: {schemeId: string; concepts: string[]; topConcepts: string[]}
+  expanded?: boolean
+  browseOnly?: boolean
+}
+
+export type BranchFilterResult = {
+  filter: string
+  params: {schemeId: string; branchId: string; concepts: string[]}
+  expanded?: boolean
+  browseOnly?: boolean
+}
+
+/** Throws if the scheme id is missing or not a string. */
+export function assertSchemeId(schemeId: unknown): asserts schemeId is string {
+  if (!schemeId || typeof schemeId !== 'string') {
+    throw new Error('Invalid or missing schemeId: scheme Id must be a string')
+  }
+}
+
+/** Throws if the branch id is missing or not a string. */
+export function assertBranchId(branchId: unknown): asserts branchId is string {
+  if (!branchId || typeof branchId !== 'string') {
+    throw new Error('Invalid or missing branchId: branch Id must be a string')
+  }
+}
+
+/** Assemble the scheme reference-filter result from the fetched concept refs. */
+export function buildSchemeFilterResult(input: {
+  schemeId: string
+  concepts: string[]
+  topConcepts: string[]
+  expanded?: boolean
+  browseOnly?: boolean
+}): SchemeFilterResult {
+  const {schemeId, concepts, topConcepts, expanded, browseOnly} = input
+  return {
+    filter: `(_id in $concepts
+              || _id in $topConcepts)`,
+    params: {concepts, topConcepts, schemeId},
+    expanded,
+    browseOnly,
+  }
+}
+
+/** Assemble the branch reference-filter result from the fetched concept refs. */
+export function buildBranchFilterResult(input: {
+  schemeId: string
+  branchId: string
+  concepts: string[]
+  expanded?: boolean
+  browseOnly?: boolean
+}): BranchFilterResult {
+  const {schemeId, branchId, concepts, expanded, browseOnly} = input
+  return {
+    filter: `_id in $concepts`,
+    params: {concepts, schemeId, branchId},
+    expanded,
+    browseOnly,
+  }
+}

package/src/core/ids.test.ts

@@ -0,0 +1,68 @@
+import {describe, expect, it} from 'vitest'
+
+import {
+  conceptReferenceStrength,
+  deriveNewConceptId,
+  deriveSchemeMutationTarget,
+  SKOS_CONCEPT_STRENGTHEN,
+} from './ids'
+
+describe('deriveSchemeMutationTarget', () => {
+  it('targets the draft id for a published scheme', () => {
+    expect(deriveSchemeMutationTarget('scheme-1')).toEqual({
+      isInRelease: false,
+      releaseName: undefined,
+      schemeId: 'drafts.scheme-1',
+    })
+  })
+
+  it('targets the draft id for a scheme that is already a draft', () => {
+    expect(deriveSchemeMutationTarget('drafts.scheme-1')).toEqual({
+      isInRelease: false,
+      releaseName: undefined,
+      schemeId: 'drafts.scheme-1',
+    })
+  })
+
+  it('targets the version id (and extracts the release) for a scheme in a release', () => {
+    expect(deriveSchemeMutationTarget('versions.rel1.scheme-1')).toEqual({
+      isInRelease: true,
+      releaseName: 'rel1',
+      schemeId: 'versions.rel1.scheme-1',
+    })
+  })
+})
+
+describe('deriveNewConceptId', () => {
+  it('creates a draft id when not in a release', () => {
+    expect(deriveNewConceptId('new-1', {isInRelease: false, releaseName: undefined})).toBe(
+      'drafts.new-1',
+    )
+  })
+
+  it('creates a version id when in a release', () => {
+    expect(deriveNewConceptId('new-1', {isInRelease: true, releaseName: 'rel1'})).toBe(
+      'versions.rel1.new-1',
+    )
+  })
+})
+
+describe('conceptReferenceStrength', () => {
+  it('is a strong (non-weak) reference when the concept is published', () => {
+    expect(conceptReferenceStrength('concept-1')).toEqual({_weak: false})
+  })
+
+  it('is weak + strengthen-on-publish when the concept is a draft', () => {
+    expect(conceptReferenceStrength('drafts.concept-1')).toEqual({
+      _weak: true,
+      _strengthenOnPublish: SKOS_CONCEPT_STRENGTHEN,
+    })
+  })
+
+  it('is weak + strengthen-on-publish when the concept is in a release', () => {
+    expect(conceptReferenceStrength('versions.rel1.concept-1')).toEqual({
+      _weak: true,
+      _strengthenOnPublish: {type: 'skosConcept', template: {id: 'skosConcept'}},
+    })
+  })
+})