@orbcharts/core 3.0.0-alpha.21

package/src/relationship/createRelationshipContextObserver.ts

@@ -0,0 +1,12 @@
+import type { ContextObserverFn } from '../types'
+
+export const createRelationshipContextObserver: ContextObserverFn<'relationship'> = ({ subject, observer }) => {
+
+  return {
+    fullParams$: observer.fullParams$,
+    fullChartParams$: observer.fullChartParams$,
+    fullDataFormatter$: observer.fullDataFormatter$,
+    computedData$: observer.computedData$,
+    layout$: observer.layout$,
+  }
+}

package/src/series/computeSeriesData.ts

@@ -0,0 +1,154 @@
+import type { DataSeries, DataSeriesDatum } from '../types/DataSeries'
+import type { ComputedDataFn } from '../types/ComputedData'
+import type { ComputedDataSeries, ComputedDatumSeries } from '../types/ComputedDataSeries'
+import { formatValueToLabel, createDefaultDatumId, createDefaultSeriesLabel } from '../utils/orbchartsUtils'
+
+interface SortValue {
+  rowIndex: number
+  columnIndex: number
+  index: number
+  datum: number | DataSeriesDatum
+}
+
+type GetSortedIndex = (computedDataSeries: ComputedDatumSeries[], rowIndex: number, columnIndex: number) => number
+
+function createSortedIndexMap (data: DataSeries, sort: (a: number | DataSeriesDatum, b: number | DataSeriesDatum) => number): Map<string, number> {
+  
+  const SortedIndexMap: Map<string, number> = new Map() // Map<[rowIndex, columnIndex], sortedIndex>
+  
+  let _data = Object.assign([], data) as DataSeries
+  // 建立排序所需資料的物件
+  let sortValueData: SortValue[] = []
+  _data.forEach((d, i) => {
+    if (Array.isArray(d)) {
+      d.forEach((_d, _i) => {
+        sortValueData.push({
+          rowIndex: i,
+          columnIndex: _i,
+          index: -1,
+          datum: _d
+        })
+      })
+    } else {
+      sortValueData.push({
+        rowIndex: i,
+        columnIndex: 0,
+        index: -1,
+        datum: d
+      })
+    }
+  })
+  // 排序
+  sortValueData.sort((a, b) => sort(a.datum, b.datum))
+  // 取得排序後的index
+  sortValueData = sortValueData.map((d, i) => {
+    return {
+      ...d,
+      index: i
+    }
+  })
+  // 建立SortedIndexMap
+  sortValueData.forEach(d => {
+    SortedIndexMap.set(String([d.rowIndex, d.columnIndex]), d.index)
+  })
+
+  return SortedIndexMap
+}
+
+export const computeSeriesData: ComputedDataFn<'series'> = (context) => {
+  const { data = [], dataFormatter, chartParams } = context
+  if (!data.length) {
+    return []
+  }
+
+  const computedDataSeries: ComputedDatumSeries[] = []
+  
+  try {
+    // 取得排序後的索引
+    const getSortedIndex: GetSortedIndex = ((hasSort: boolean) => {
+      if (hasSort) {
+        // 資料索引對應排序後的索引  Map<[rowIndex, columnIndex], sortedIndex>
+        const SortedIndexMap: Map<string, number> = createSortedIndexMap(data, dataFormatter.sort)
+        return (computedDataSeries: ComputedDatumSeries[], rowIndex: number, columnIndex: number) => {
+          return SortedIndexMap.get(String([rowIndex, columnIndex]))
+        }
+      } else {
+        return (computedDataSeries: ComputedDatumSeries[], rowIndex: number, columnIndex: number) => {
+          return computedDataSeries.length
+        }
+      }
+    })(dataFormatter.sort != null)
+
+    // 資料索引對應排序後的索引  Map<[rowIndex, columnIndex], sortedIndex>
+    // let SortedIndexMap: Map<string, number> = new Map()
+    // if (dataFormatter.sort) {
+    //   SortedIndexMap = createSortedIndexMap(data, dataFormatter.sort)
+    // }
+    
+    // const seriesColors = chartParams.colors[chartParams.colorScheme].series
+
+    const createComputedDatumSeries = (detailData: number | DataSeriesDatum, rowIndex: number, columnIndex: number, currentIndex: number, sortedIndex: number): ComputedDatumSeries => {
+      const defaultId = createDefaultDatumId(dataFormatter.type, rowIndex, columnIndex)
+      // const seriesLabel = dataFormatter.mapSeries(detailData, rowIndex, columnIndex, context)
+      const seriesLabel = dataFormatter.seriesLabels[rowIndex] || createDefaultSeriesLabel('series', rowIndex)
+      // const color = seriesColors[rowIndex]
+      const color = dataFormatter.colorsPredicate(detailData, rowIndex, columnIndex, context)
+      const visible = dataFormatter.visibleFilter(detailData, rowIndex, columnIndex, context)
+      if (typeof detailData === 'number') {
+        return {
+          id: defaultId,
+          index: currentIndex,
+          sortedIndex,
+          label: defaultId,
+          tooltipContent: dataFormatter.tooltipContentFormat(detailData, rowIndex, columnIndex, context),
+          data: {},
+          value: detailData,
+          // valueLabel: formatValueToLabel(detailData, dataFormatter.valueFormat),
+          seriesIndex: rowIndex,
+          seriesLabel,
+          color,
+          visible
+        }
+      } else {
+        return {
+          id: detailData.id ? detailData.id : defaultId,
+          index: currentIndex,
+          sortedIndex,
+          label: detailData.label ? detailData.label : defaultId,
+          tooltipContent: detailData.tooltipContent ? detailData.tooltipContent : dataFormatter.tooltipContentFormat(detailData, rowIndex, columnIndex, context),
+          data: detailData.data ?? {},
+          value: detailData.value,
+          // valueLabel: formatValueToLabel(detailData.value, dataFormatter.valueFormat),
+          seriesIndex: rowIndex,
+          seriesLabel,
+          color,
+          visible
+        }
+      }
+    }
+
+    
+    data.forEach((mainData, rowIndex) => {
+      if (Array.isArray(mainData)) {
+        mainData.forEach((detailData, columnIndex) => {
+          const sortedIndex = getSortedIndex(computedDataSeries, rowIndex, columnIndex)
+          const datum = createComputedDatumSeries(detailData, rowIndex, columnIndex, computedDataSeries.length, sortedIndex)
+          computedDataSeries.push(datum)
+        })
+      } else {
+        const sortedIndex = getSortedIndex(computedDataSeries, rowIndex, 0)
+        const datum = createComputedDatumSeries(mainData, rowIndex, 0, computedDataSeries.length, sortedIndex) // 只有一維陣列所以columnIndex為0
+        computedDataSeries.push(datum)
+      }
+    })
+
+    // if (dataFormatter.sort != null) {
+    //   computedDataSeries.sort((a, b) => a.sortedIndex - b.sortedIndex)
+    // }
+  } catch (e) {
+    // console.error(e)
+    throw Error(e)
+  }
+  
+  return computedDataSeries
+}

package/src/series/createSeriesContextObserver.ts

@@ -0,0 +1,33 @@
+import { shareReplay } from 'rxjs'
+import type { ContextObserverFn } from '../types'
+import {
+  highlightObservable,
+  seriesDataMapObservable,
+  groupDataMapObservable } from '../utils/observables'
+
+export const createSeriesContextObserver: ContextObserverFn<'series'> = ({ subject, observer }) => {
+
+  const seriesHighlight$ = highlightObservable({
+    datumList$: observer.computedData$,
+    fullChartParams$: observer.fullChartParams$,
+    event$: subject.event$
+  }).pipe(
+    shareReplay(1)
+  )
+
+  const SeriesDataMap$ = seriesDataMapObservable({
+    datumList$: observer.computedData$
+  }).pipe(
+    shareReplay(1)
+  )
+
+  return {
+    fullParams$: observer.fullParams$,
+    fullChartParams$: observer.fullChartParams$,
+    fullDataFormatter$: observer.fullDataFormatter$,
+    computedData$: observer.computedData$,
+    layout$: observer.layout$,
+    seriesHighlight$,
+    SeriesDataMap$
+  }
+}

package/src/series/seriesObservables.ts

@@ -0,0 +1,23 @@
+import {
+  combineLatest,
+  distinctUntilChanged,
+  filter,
+  map,
+  merge,
+  takeUntil,
+  shareReplay,
+  switchMap,
+  Subject,
+  Observable } from 'rxjs'
+import type {
+  ChartParams,
+  ComputedDataTypeMap } from '../types'
+import { highlightObservable } from '../utils/observables'
+
+export const seriesHighlightObservable = ({ computedData$, fullChartParams$, event$ }: {
+  computedData$: Observable<ComputedDataTypeMap<'series'>>
+  fullChartParams$: Observable<ChartParams>
+  event$: Subject<any>
+}): Observable<string[]> => {
+  return highlightObservable ({ datumList$: computedData$, fullChartParams$, event$ })
+}

package/src/tree/computeTreeData.ts

@@ -0,0 +1,104 @@
+import type { DataTree, DataTreeObj, DataTreeDatum } from '../types/DataTree'
+import type { ComputedDataFn } from '../types/ComputedData'
+import type { ComputedDataTree } from '../types/ComputedDataTree'
+import { isObject } from '../utils/commonUtils'
+
+export const computeTreeData: ComputedDataFn<'tree'> = (context) => {
+  const { data = [], dataFormatter, chartParams } = context
+
+  let computedBranchData: ComputedDataTree = {
+    id: '',
+    index: 0,
+    label: '',
+    visible: true,
+    tooltipContent: '',
+    data: {},
+    value: 0,
+    level: 0,
+    seq: 0,
+    children: []
+  }
+
+  try {
+    // 建立樹狀結構資料
+    const dataTreeObj: DataTreeObj = (function () {
+      if (isObject(data) === true) {
+        // 原本就是樹狀結構則直接複製
+        return structuredClone(data) as DataTreeObj
+      } else if (Array.isArray(data) === false) {
+        return {
+          id: ''
+        }
+      }
+      // -- 陣列格式轉物件 --
+      // let rootId = ''
+      let root: DataTreeDatum | undefined = undefined
+      // const DataMap: Map<string, DataTreeDatum> = new Map()
+      const ChildrenMap: Map<string, DataTreeDatum[]> = new Map()
+      ;(data as DataTreeDatum[]).forEach(d => {
+        // DataMap.set(d.id, d)
+
+        if (!d.parent) {
+          // rootId = d.id
+          root = d
+        } else {
+          const children: DataTreeDatum[] = ChildrenMap.get(d.parent) ?? []
+          children.push(d)
+          ChildrenMap.set(d.parent!, children)
+        }
+      })
+
+      const createBranchData = (root: DataTreeDatum): DataTreeObj => {
+        return {
+          id: root.id,
+          label: root.label,
+          data: root.data,
+          tooltipContent: root.tooltipContent,
+          value: root.value,
+          children: (ChildrenMap.get(root.id) ?? []).map(d => {
+            // 遞迴
+            return createBranchData(d)
+          })
+        }
+      }
+      if (root) {
+        return createBranchData(root)
+      } else {
+        return {
+          id: ''
+        }
+      }    
+    })()
+
+    let index = 0
+    
+    const formatBranchData = (branchRoot: DataTreeObj, level: number, seq: number): ComputedDataTree => {
+      const childLayer = level + 1
+      const visible = dataFormatter.visibleFilter(branchRoot, level, seq, context)
+      const currentIndex = index
+      index++
+      return {
+        id: branchRoot.id,
+        index: currentIndex,
+        level,
+        seq,
+        label: branchRoot.label ?? '',
+        data: branchRoot.data ?? {},
+        tooltipContent: branchRoot.tooltipContent ? branchRoot.tooltipContent : dataFormatter.tooltipContentFormat(branchRoot, level, seq, context),
+        value: branchRoot.value,
+        visible,
+        children: (branchRoot.children ?? []).map((d, i) => {
+          // 遞迴
+          return formatBranchData(d, childLayer, i)
+        })
+      }
+    }
+    computedBranchData = formatBranchData(dataTreeObj, 0, 0)
+  } catch (e) {
+    // console.error(e)
+    throw Error(e)
+  }
+
+  return computedBranchData
+
+}

package/src/tree/createTreeContextObserver.ts

@@ -0,0 +1,12 @@
+import type { ContextObserverFn } from '../types'
+
+export const createTreeContextObserver: ContextObserverFn<'tree'> = ({ subject, observer }) => {
+
+  return {
+    fullParams$: observer.fullParams$,
+    fullChartParams$: observer.fullChartParams$,
+    fullDataFormatter$: observer.fullDataFormatter$,
+    computedData$: observer.computedData$,
+    layout$: observer.layout$,
+  }
+}

package/src/types/Axis.ts

@@ -0,0 +1 @@
+export type AxisPosition = 'top' | 'bottom' | 'left' | 'right'

package/src/types/Chart.ts

@@ -0,0 +1,46 @@
+import type { ChartParams, ChartParamsPartial } from './ChartParams'
+import type { ContextSubject } from './ContextSubject'
+import type { ContextObserverFn } from './ContextObserver'
+import type { ComputedDataFn } from './ComputedData'
+import type { DataFormatterTypeMap, DataFormatterPartialTypeMap } from './DataFormatter'
+
+export type ChartType = 'series' | 'grid' | 'multiGrid' | 'multiValue' | 'tree' | 'relationship'
+
+export interface CreateBaseChart {
+  <T extends ChartType>({ defaultDataFormatter, computedDataFn, contextObserverFn }: {
+    defaultDataFormatter: DataFormatterTypeMap<T>
+    computedDataFn: ComputedDataFn<T>
+    contextObserverFn: ContextObserverFn<T>
+  }): CreateChart<T>
+}
+
+
+export interface CreateChart<T extends ChartType> {
+  // (element: HTMLElement | Element, pluginParams: any[], chartParams?: Partial<ChartParams>): Chart<T>
+  (element: HTMLElement | Element, options?: ChartOptionsPartial<T>): ChartEntity<T>
+}
+
+export interface ChartEntity<T extends ChartType> extends ContextSubject<T> {
+  selection: d3.Selection<SVGGElement, unknown, HTMLElement, unknown>
+  destroy: () => void
+}
+
+export interface ChartOptions<T extends ChartType> {
+  preset: Preset<T>
+}
+
+export interface ChartOptionsPartial<T extends ChartType> {
+  preset?: PresetPartial<T>
+}
+
+export interface Preset<T extends ChartType> {
+  chartParams:  ChartParams
+  dataFormatter:  DataFormatterTypeMap<T>
+  allPluginParams:  {[key: string]: any}
+}
+
+export interface PresetPartial<T extends ChartType> {
+  chartParams?:  ChartParamsPartial
+  dataFormatter?:  DataFormatterPartialTypeMap<T>
+  allPluginParams?:  {[key: string]: any}
+}

package/src/types/ChartParams.ts

@@ -0,0 +1,50 @@
+import type { Padding } from './Padding'
+
+
+export interface ChartParams {
+  padding: Padding,
+  // colors: string[],
+  highlightTarget: HighlightTarget
+  // highlightDefault: HighlightDefault
+  highlightDefault: string | null
+  colorScheme: 'dark' | 'light'
+  colors: {
+    light: ColorScheme
+    dark: ColorScheme
+  }
+  styles: Styles
+  transitionDuration: number
+  transitionEase: string
+  // [key: string]: any
+}
+
+export type ChartParamsPartial = {
+  padding?: Partial<Padding>,
+  colors?: {
+    light?: Partial<ColorScheme>
+    dark?: Partial<ColorScheme>
+  }
+  styles?: Partial<Styles>
+}
+
+// export interface HighlightDefault {
+//   id: string | null
+//   label: string | null
+// }
+
+export type HighlightTarget = 'series' | 'group' | 'datum' | 'none'
+
+export interface Styles {
+  textSize: number
+  unhighlightedOpacity: number
+}
+
+export interface ColorScheme {
+  series: string[]
+  primary: string
+  secondary: string
+  white: string
+  background: string
+}
+
+export type ColorType = keyof ColorScheme

package/src/types/ComputedData.ts

@@ -0,0 +1,66 @@
+import type { ChartType } from './Chart'
+import type { ComputedDataSeries, ComputedDatumSeries } from './ComputedDataSeries'
+import type { ComputedDataGrid, ComputedDatumGrid } from './ComputedDataGrid'
+import type { ComputedDataMultiGrid } from './ComputedDataMultiGrid'
+import type { ComputedDataMultiValue, ComputedDatumMultiValue } from './ComputedDataMultiValue'
+import type { ComputedDataRelationship, ComputedNode } from './ComputedDataRelationship'
+import type { ComputedDataTree } from './ComputedDataTree'
+import type { DataFormatterContext } from './DataFormatter'
+
+export interface ComputedDataFn<T extends ChartType> {
+  (dataFormatterContext: DataFormatterContext<T>): ComputedDataTypeMap<T>
+}
+
+// datum - 基本型本
+export interface ComputedDatumBase {
+  id: string
+  index: number
+  label: string
+  value: number | null
+  visible: boolean
+  tooltipContent: string
+  data: any // 使用者注入的資料
+}
+
+// datum - 單值
+// export interface ComputedDatumValue {
+//   value: number | null
+//   // valueLabel: string
+// }
+
+// datum - 多值
+// export interface ComputedDatumMultiValue {
+//   value: number[]
+//   valueLabels: string[]
+// }
+
+// datum - 圖軸
+// export interface ComputedDatumWithAxis {
+//   axisX: number
+//   axisY: number
+// }
+
+// datum - 序列顏色
+export interface ComputedDatumSeriesValue {
+  color: string
+  seriesIndex: number
+  seriesLabel: string
+}
+
+// 透過類型選擇ComputedData
+export type ComputedDataTypeMap<T extends ChartType> = T extends 'series' ? ComputedDataSeries
+  : T extends 'grid' ? ComputedDataGrid
+  : T extends 'multiGrid' ? ComputedDataMultiGrid
+  : T extends 'multiValue' ? ComputedDataMultiValue
+  : T extends 'relationship' ? ComputedDataRelationship
+  : T extends 'tree' ? ComputedDataTree
+  : ComputedDatumBase
+
+// 透過類型選擇ComputedDatum
+export type ComputedDatumTypeMap<T extends ChartType> = T extends 'series' ? ComputedDatumSeries
+: T extends 'grid' ? ComputedDatumGrid
+: T extends 'multiGrid' ? ComputedDatumGrid
+: T extends 'multiValue' ? ComputedDatumMultiValue
+: T extends 'relationship' ? ComputedNode
+: T extends 'tree' ? ComputedDataTree
+: unknown

package/src/types/ComputedDataGrid.ts

@@ -0,0 +1,12 @@
+import { ComputedDatumBase, ComputedDatumSeriesValue } from './ComputedData'
+
+export interface ComputedDatumGrid
+  extends ComputedDatumBase, ComputedDatumSeriesValue {
+  groupIndex: number
+  groupLabel: string
+  axisX: number
+  axisY: number
+  axisYFromZero: number
+}
+
+export type ComputedDataGrid = ComputedDatumGrid[][]

package/src/types/ComputedDataMultiGrid.ts

@@ -0,0 +1,3 @@
+import { ComputedDataGrid } from './ComputedDataGrid'
+
+export type ComputedDataMultiGrid = ComputedDataGrid[]

package/src/types/ComputedDataMultiValue.ts

@@ -0,0 +1,10 @@
+import type { ComputedDatumBase } from './ComputedData'
+
+export type ComputedDataMultiValue = ComputedDatumMultiValue[][]
+
+export interface ComputedDatumMultiValue
+  extends ComputedDatumBase {
+  axis: number
+}
+
+

package/src/types/ComputedDataRelationship.ts

@@ -0,0 +1,20 @@
+import type { ComputedDatumBase } from './ComputedData'
+
+export type ComputedDataRelationship = {
+  nodes: ComputedNode[]
+  edges: ComputedEdge[]
+}
+
+export interface ComputedNode extends ComputedDatumBase {
+  startNodes: ComputedNode[]
+  startNodeIds: string[]
+  endNodes: ComputedNode[]
+  endNodeIds: string[]
+}
+
+export interface ComputedEdge extends ComputedDatumBase {
+  startNode: ComputedNode
+  startNodeId: string
+  endNode: ComputedNode
+  endNodeId: string
+}

package/src/types/ComputedDataSeries.ts

@@ -0,0 +1,8 @@
+import { ComputedDatumBase, ComputedDatumSeriesValue } from './ComputedData'
+
+export interface ComputedDatumSeries
+  extends ComputedDatumBase, ComputedDatumSeriesValue {
+  sortedIndex: number
+}
+
+export type ComputedDataSeries = ComputedDatumSeries[]

package/src/types/ComputedDataTree.ts

@@ -0,0 +1,20 @@
+import type { ComputedDatumBase } from './ComputedData'
+
+// export type ComputedDataTree = ComputedDataTreeDatum[]
+
+// export interface ComputedDataTreeDatum extends ComputedDatum {
+//   // id: string
+//   children: ComputedDataTreeDatum[]
+//   childrenIds: string[]
+// //   ChildrenMap: Map<string, ComputedDataTreeDatum>
+//   parent: ComputedDataTreeDatum
+//   parentId: string
+//   value?: number
+// }
+
+// 樹狀結構
+export interface ComputedDataTree extends ComputedDatumBase {
+  level: number
+  seq: number
+  children?: ComputedDataTree[]
+}

package/src/types/ContextObserver.ts

@@ -0,0 +1,38 @@
+import { Observable, Subject, BehaviorSubject } from 'rxjs'
+import type { ChartType } from './Chart'
+import type { ChartParams } from './ChartParams'
+import type { DataFormatterTypeMap } from './DataFormatter'
+import type { ComputedDataTypeMap } from './ComputedData'
+import type { Layout } from './Layout'
+import type { ContextObserverGrid } from './ContextObserverGrid'
+import type { ContextObserverMultiGrid } from './ContextObserverMultiGrid'
+import type { ContextObserverMultiValue } from './ContextObserverMultiValue'
+import type { ContextObserverRelationship } from './ContextObserverRelationship'
+import type { ContextObserverSeries } from './ContextObserverSeries'
+import type { ContextObserverTree } from './ContextObserverTree'
+import type { ContextSubject } from './ContextSubject'
+
+export interface ContextObserverFn<T extends ChartType> {
+  ({ subject, observer }: {
+    subject: ContextSubject<T>
+    observer: ContextObserverBase<T, unknown>
+  }): ContextObserverTypeMap<T, unknown>
+}
+
+// ContextObserver
+export type ContextObserverTypeMap<T extends ChartType, PluginParams> = T extends 'series' ? ContextObserverSeries<PluginParams>
+  : T extends 'grid' ? ContextObserverGrid<PluginParams>
+  : T extends 'multiGrid' ? ContextObserverMultiGrid<PluginParams>
+  : T extends 'multiValue' ? ContextObserverMultiValue<PluginParams>
+  : T extends 'relationship' ? ContextObserverRelationship<PluginParams>
+  : T extends 'tree' ? ContextObserverTree<PluginParams>
+  : ContextObserverBase<ChartType, PluginParams>
+
+export interface ContextObserverBase<T extends ChartType, PluginParams> {
+  fullParams$: Observable<PluginParams>
+  fullChartParams$: Observable<ChartParams>
+  fullDataFormatter$: Observable<DataFormatterTypeMap<T>>
+  computedData$: Observable<ComputedDataTypeMap<T>>
+  layout$: Observable<Layout>
+}
+

package/src/types/ContextObserverGrid.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs'
+import type { ContextObserverBase } from './ContextObserver'
+import type { ComputedDataGrid, ComputedDatumGrid } from './ComputedDataGrid'
+import type { TransformData } from './TransformData'
+
+export interface ContextObserverGrid<PluginParams> extends ContextObserverBase<'grid', PluginParams> {
+  gridAxesTransform$: Observable<TransformData>
+  gridGraphicTransform$: Observable<TransformData>
+  gridAxesOppositeTransform$: Observable<TransformData>
+  gridAxesSize$: Observable<{ width: number; height: number; }>
+  gridHighlight$: Observable<string[]>
+  SeriesDataMap$: Observable<Map<string, ComputedDatumGrid[]>>
+  GroupDataMap$: Observable<Map<string, ComputedDatumGrid[]>>
+  visibleComputedData$: Observable<ComputedDataGrid>
+}
+

package/src/types/ContextObserverMultiGrid.ts

@@ -0,0 +1,5 @@
+import type { ContextObserverBase } from './ContextObserver'
+
+export interface ContextObserverMultiGrid<PluginParams> extends ContextObserverBase<'multiGrid', PluginParams> {
+
+}

package/src/types/ContextObserverMultiValue.ts

@@ -0,0 +1,5 @@
+import type { ContextObserverBase } from './ContextObserver'
+
+export interface ContextObserverMultiValue<PluginParams> extends ContextObserverBase<'multiValue', PluginParams> {
+
+}

package/src/types/ContextObserverRelationship.ts

@@ -0,0 +1,5 @@
+import type { ContextObserverBase } from './ContextObserver'
+
+export interface ContextObserverRelationship<PluginParams> extends ContextObserverBase<'relationship', PluginParams> {
+
+}