@orbcharts/plugins-basic 3.0.0-alpha.30 → 3.0.0-alpha.32

package/src/base/BaseLegend.ts

@@ -20,12 +20,22 @@ export interface BaseLegendParams {
   backgroundFill: ColorType
   backgroundStroke: ColorType
   gap: number
-  listRectWidth: number
-  listRectHeight: number
-  listRectRadius: number
+  seriesList: Array<{
+    listRectWidth: number
+    listRectHeight: number
+    listRectRadius: number
+  }>
   // highlightEvent: boolean
 }
 
+interface BaseLegendContext {
+  rootSelection: d3.Selection<any, unknown, any, unknown>
+  seriesLabels$: Observable<string[]>
+  fullParams$: Observable<BaseLegendParams>
+  layout$: Observable<Layout>
+  fullChartParams$: Observable<ChartParams>
+}
+
 // 第1層 - 定位的容器
 interface RootPosition {
   x:number
@@ -62,22 +72,29 @@ interface LegendItem {
   translateX: number
   translateY: number
   color: string
-  // fontSize: number
-  // listRectRadius: number
+  listRectWidth: number
+  listRectHeight: number
+  listRectRadius: number
 }
 
-export const createBaseLegend: BasePluginFn = (pluginName: string, {
+interface ListStyle {
+  listRectWidth: number
+  listRectHeight: number
+  listRectRadius: number
+}
+
+const defaultListStyle: ListStyle = {
+  listRectWidth: 14,
+  listRectHeight: 14,
+  listRectRadius: 0,
+}
+
+export const createBaseLegend: BasePluginFn<BaseLegendContext> = (pluginName: string, {
   rootSelection,
   seriesLabels$,
   fullParams$,
   layout$,
   fullChartParams$
-}: {
-  rootSelection: d3.Selection<any, unknown, any, unknown>
-  seriesLabels$: Observable<string[]>
-  fullParams$: Observable<BaseLegendParams>
-  layout$: Observable<Layout>
-  fullChartParams$: Observable<ChartParams>
 }) => {
 
   const rootPositionClassName = getClassName(pluginName, 'root-position')
@@ -196,13 +213,21 @@ export const createBaseLegend: BasePluginFn = (pluginName: string, {
     })
   )
 
+  const defaultListStyle$ = fullParams$.pipe(
+    takeUntil(destroy$),
+    map(data => {
+      return data.seriesList[0] ? data.seriesList[0] : defaultListStyle
+    })
+  )
+
   // 先計算list內每個item
   const lengendItems$: Observable<LegendItem[][]> = combineLatest({
     fullParams: fullParams$,
     fullChartParams: fullChartParams$,
     seriesLabels: seriesLabels$,
     lineDirection: lineDirection$,
-    lineMaxSize: lineMaxSize$
+    lineMaxSize: lineMaxSize$,
+    defaultListStyle: defaultListStyle$
   }).pipe(
     takeUntil(destroy$),
     switchMap(async d => d),
@@ -266,6 +291,8 @@ export const createBaseLegend: BasePluginFn = (pluginName: string, {
           prev[lineIndex] = []
         }
 
+        const listStyle = data.fullParams.seriesList[itemIndex] ? data.fullParams.seriesList[itemIndex] : data.defaultListStyle
+
         prev[lineIndex].push({
           id: current,
           seriesLabel: current,
@@ -277,8 +304,11 @@ export const createBaseLegend: BasePluginFn = (pluginName: string, {
           translateX,
           translateY,
           color,
+          listRectWidth: listStyle.listRectWidth,
+          listRectHeight: listStyle.listRectHeight,
+          listRectRadius: listStyle.listRectRadius
         })
-        console.log('items', prev)
+        
         return prev
       }, [])
     })
@@ -499,8 +529,8 @@ export const createBaseLegend: BasePluginFn = (pluginName: string, {
         })
         .each((d, i, g) => {
           const rectCenterX = data.fullChartParams.styles.textSize / 2
-          const rectWidth = data.fullParams.listRectWidth
-          const rectHeight = data.fullParams.listRectHeight
+          const transformRectWidth = - d.listRectWidth / 2
+          const transformRectHeight = - d.listRectHeight / 2
           // 方塊
           d3.select(g[i])
             .selectAll('rect')
@@ -508,11 +538,11 @@ export const createBaseLegend: BasePluginFn = (pluginName: string, {
             .join('rect')
             .attr('x', rectCenterX)
             .attr('y', rectCenterX)
-            .attr('width', rectWidth)
-            .attr('height', rectHeight)
-            .attr('transform', `translate(${- rectWidth / 2}, ${- rectHeight / 2})`)
+            .attr('width', _d => _d.listRectWidth)
+            .attr('height', _d => _d.listRectHeight)
+            .attr('transform', _d => `translate(${transformRectWidth}, ${transformRectHeight})`)
             .attr('fill', _d => _d.color)
-            .attr('rx', data.fullParams.listRectRadius)
+            .attr('rx', _d => _d.listRectRadius)
           // 文字
           d3.select(g[i])
             .selectAll('text')

package/src/base/BaseLines.ts

@@ -0,0 +1,566 @@
+import * as d3 from 'd3'
+import {
+  combineLatest,
+  map,
+  filter,
+  switchMap,
+  takeUntil,
+  distinctUntilChanged,
+  Observable,
+  Subject } from 'rxjs'
+import type { BasePluginFn } from './types'
+import type {
+  ComputedDatumGrid,
+  ComputedDataGrid,
+  DataFormatterGrid,
+  EventGrid,
+  ChartParams, 
+  Layout,
+  TransformData } from '@orbcharts/core'
+import { getD3TransitionEase } from '../utils/d3Utils'
+import { getClassName, getUniID } from '../utils/orbchartsUtils'
+import { gridGroupPositionFnObservable } from '../grid/gridObservables'
+
+export interface BaseLinesParams {
+  // lineType: LineType
+  lineCurve: string
+  lineWidth: number
+  // labelFn: (d: ComputedDatumSeries) => string
+  // labelPositionFn: (d: ComputedDatumSeries) => 'top' | 'bottom' | 'left' | 'right' | 'center'
+  // labelStyleFn: (d: ComputedDatumSeries) => string
+  // labelFontSizeFn: (d: ComputedDatumSeries) => number
+  // labelColorFn: (d: ComputedDatumSeries) => string
+  // labelPadding: number
+}
+
+interface BaseLinesContext {
+  selection: d3.Selection<any, unknown, any, unknown>
+  computedData$: Observable<ComputedDataGrid>
+  SeriesDataMap$: Observable<Map<string, ComputedDatumGrid[]>>
+  GroupDataMap$: Observable<Map<string, ComputedDatumGrid[]>>
+  fullDataFormatter$: Observable<DataFormatterGrid>
+  fullParams$: Observable<BaseLinesParams>
+  fullChartParams$: Observable<ChartParams>
+  gridAxesTransform$: Observable<TransformData>
+  gridGraphicTransform$: Observable<TransformData>
+  gridAxesSize$: Observable<{
+    width: number;
+    height: number;
+  }>
+  gridHighlight$: Observable<string[]>
+  event$: Subject<EventGrid>
+}
+
+
+type ClipPathDatum = {
+  id: string;
+  // x: number;
+  // y: number;
+  width: number;
+  height: number;
+}
+
+const pluginName = 'Lines'
+const gClassName = getClassName(pluginName, 'g')
+const pathClassName = getClassName(pluginName, 'path')
+
+function createLinePath (lineCurve: string = 'curveLinear'): d3.Line<ComputedDatumGrid> {
+  return d3.line<ComputedDatumGrid>()
+    .x((d) => d.axisX)
+    .y((d) => d.axisY)
+    .curve((d3 as any)[lineCurve])
+}
+
+// function renderGraphicG ({ selection }) {
+
+// }
+
+// 依無值的資料分段
+function  makeSegmentData (data: ComputedDatumGrid[]): ComputedDatumGrid[][] {
+  let segmentData: ComputedDatumGrid[][] = [[]]
+
+  let currentIndex = 0
+  for (let i in data) {
+    if (data[i].visible == false || data[i].value === undefined || data[i].value === null) {
+      // 換下一段的 index
+      if (segmentData[currentIndex].length) {
+        currentIndex ++
+        segmentData[currentIndex] = []
+      }
+      continue
+    }
+    segmentData[currentIndex].push(data[i])
+  }
+
+  return segmentData
+}
+
+
+function renderLine ({ selection, segmentData, linePath, params }: {
+  selection: d3.Selection<SVGGElement, unknown, any, unknown>
+  segmentData: ComputedDatumGrid[][]
+  linePath: d3.Line<ComputedDatumGrid>
+  params: BaseLinesParams
+}): d3.Selection<SVGPathElement, ComputedDatumGrid[], any, any> {
+  // if (!data[0]) {
+  //   return undefined
+  // }
+
+  const lines = selection
+    .selectAll<SVGPathElement, ComputedDatumGrid[]>('path')
+    .data(segmentData, (d, i) => d.length ? `${d[0].id}_${d[d.length - 1].id}` : i) // 以線段起迄id結合為線段id
+    .join(
+      enter => {
+        return enter
+          .append<SVGPathElement>('path')
+          .classed(pathClassName, true)
+          .attr("fill","none")
+          .attr('pointer-events', 'visibleStroke') // 只對線條產生事件
+          .style('vector-effect', 'non-scaling-stroke')
+          .style('cursor', 'pointer')
+      },
+      update => update,
+      exit => exit.remove()
+    )
+    .attr("stroke-width", params.lineWidth)
+    .attr("stroke", (d, i) => d[0] && d[0].color)
+    .attr("d", (d) => {
+      return linePath(d)
+    })
+
+  return lines
+}
+
+function highlightLine ({ selection, seriesLabel, fullChartParams }: {
+  selection: d3.Selection<any, string, any, any>
+  seriesLabel: string | null
+  fullChartParams: ChartParams
+}) {
+  selection.interrupt('highlight')
+  if (!seriesLabel) {
+    // remove highlight
+    selection
+      .transition('highlight')
+      .duration(200)
+      .style('opacity', 1)
+    return
+  }
+  
+  selection
+    .each((d, i, n) => {
+      if (d === seriesLabel) {
+        d3.select(n[i])
+          .style('opacity', 1)
+      } else {
+        d3.select(n[i])
+          .style('opacity', fullChartParams.styles.unhighlightedOpacity)
+      }
+    })
+}
+
+function renderClipPath ({ defsSelection, clipPathData, transitionDuration, transitionEase }: {
+  defsSelection: d3.Selection<SVGDefsElement, any, any, any>
+  clipPathData: ClipPathDatum[]
+  transitionDuration: number
+  transitionEase: string
+}) {
+  const clipPath = defsSelection
+    .selectAll<SVGClipPathElement, Layout>('clipPath')
+    .data(clipPathData)
+    .join(
+      enter => {
+        return enter
+          .append('clipPath')
+      },
+      update => update,
+      exit => exit.remove()
+    )
+    .attr('id', d => d.id)
+    .each((d, i, g) => {
+      const rect = d3.select(g[i])
+        .selectAll<SVGRectElement, typeof d>('rect')
+        .data([d])
+        .join(
+          enter => {
+            const enterSelection = enter
+              .append('rect')
+            enterSelection
+              .transition()
+              .duration(transitionDuration)
+              .ease(getD3TransitionEase(transitionEase))
+              // .delay(100) // @Q@ 不知為何如果沒加 delay位置會有點跑掉
+              .tween('tween', (_d, _i, _g) => {
+                return (t) => {
+                  const transitionWidth = _d.width * t
+
+                  enterSelection
+                    .attr('x', 0)
+                    .attr('y', 0)
+                    .attr('width', _d => transitionWidth)
+                    .attr('height', _d => _d.height)
+                }
+              })
+            return enterSelection
+          },
+          update => {
+            return update
+              .attr('x', 0)
+              .attr('y', 0)
+              .attr('width', _d => _d.width)
+              .attr('height', _d => _d.height)
+          },
+          exit => exit.remove()
+        )
+    })
+
+}
+
+export const createBaseLines: BasePluginFn<BaseLinesContext> = (pluginName: string, {
+  selection,
+  computedData$,
+  SeriesDataMap$,
+  GroupDataMap$,
+  fullParams$,
+  fullDataFormatter$,
+  fullChartParams$,
+  gridAxesTransform$,
+  gridGraphicTransform$,
+  gridAxesSize$,
+  gridHighlight$,
+  event$
+}) => {
+
+  const destroy$ = new Subject()
+
+  const clipPathID = getUniID(pluginName, 'clipPath-box')
+
+  const axisSelection: d3.Selection<SVGGElement, any, any, any> = selection
+    .append('g')
+    .attr('clip-path', `url(#${clipPathID})`)
+  const defsSelection: d3.Selection<SVGDefsElement, any, any, any> = axisSelection.append('defs')
+  const graphicGSelection: d3.Selection<SVGGElement, any, any, any> = axisSelection.append('g')
+  const graphicSelection$: Subject<d3.Selection<SVGGElement, string, any, any>> = new Subject()
+  // let pathSelection: d3.Selection<SVGPathElement, ComputedDatumGrid[], any, any> | undefined
+  // .style('transform', 'translate(0px, 0px) scale(1)')
+
+  gridAxesTransform$
+    .pipe(
+      takeUntil(destroy$),
+      map(d => d.value),
+      distinctUntilChanged()
+    ).subscribe(d => {
+      axisSelection
+        .style('transform', d)
+    })
+
+  gridGraphicTransform$
+    .pipe(
+      takeUntil(destroy$),
+      map(d => d.value),
+      distinctUntilChanged()
+    ).subscribe(d => {
+      graphicGSelection
+        .transition()
+        .duration(50)
+        .style('transform', d)
+    })
+
+  const linePath$: Observable<d3.Line<ComputedDatumGrid>> = new Observable(subscriber => {
+    const paramsSubscription = fullParams$
+      .pipe(
+        takeUntil(destroy$)
+      )
+      .subscribe(d => {
+        if (!d) return
+        const linePath = createLinePath(d.lineCurve)
+        subscriber.next(linePath)
+      })
+    return () => {
+      paramsSubscription.unsubscribe()
+    }
+  })
+
+  // 顯示範圍內的series labels
+  const seriesLabels$: Observable<string[]> = new Observable(subscriber => {
+    computedData$.pipe(
+      takeUntil(destroy$),
+      // 轉換後會退訂前一個未完成的訂閱事件，因此可以取到「同時間」最後一次的訂閱事件
+      switchMap(async (d) => d),
+    ).subscribe(data => {
+      const labels = data[0] && data[0][0]
+        ? data.map(d => d[0].seriesLabel)
+        : []
+      subscriber.next(labels)
+    })
+  })
+
+  // const axisSize$ = gridAxisSizeObservable({
+  //   fullDataFormatter$,
+  //   computedLayout$
+  // })
+
+  const transitionDuration$ = fullChartParams$
+    .pipe(
+      map(d => d.transitionDuration),
+      distinctUntilChanged()
+    )
+
+  const transitionEase$ = fullChartParams$
+    .pipe(
+      map(d => d.transitionEase),
+      distinctUntilChanged()
+    )
+
+  const clipPathSubscription = combineLatest({
+    seriesLabels: seriesLabels$,
+    axisSize: gridAxesSize$,
+    transitionDuration: transitionDuration$,
+    transitionEase: transitionEase$
+  }).pipe(
+    takeUntil(destroy$),
+    // 轉換後會退訂前一個未完成的訂閱事件，因此可以取到「同時間」最後一次的訂閱事件
+    switchMap(async (d) => d),
+  ).subscribe(data => {
+    // 外層的遮罩
+    const clipPathBox = [{
+      id: clipPathID,
+      width: data.axisSize.width,
+      height: data.axisSize.height
+    }]
+    // 各別線條的遮罩（各別動畫）
+    const clipPathData = clipPathBox.concat(
+      data.seriesLabels.map(d => {
+        return {
+          id: `orbcharts__clipPath_${d}`,
+          width: data.axisSize.width,
+          height: data.axisSize.height
+        }
+      })
+    )
+    renderClipPath({
+      defsSelection,
+      clipPathData,
+      transitionDuration: data.transitionDuration,
+      transitionEase: data.transitionEase
+    })
+  })
+
+  // const SeriesDataMap$ = computedData$.pipe(
+  //   map(d => makeGridSeriesDataMap(d))
+  // )
+
+  // const GroupDataMap$ = computedData$.pipe(
+  //   map(d => makeGridGroupDataMap(d))
+  // )
+
+  const DataMap$ = computedData$.pipe(
+    map(d => {
+      const DataMap: Map<string, ComputedDatumGrid> = new Map()
+      d.flat().forEach(_d => DataMap.set(_d.id, _d))
+      return DataMap
+    })
+  )
+
+  // 取得事件座標的group資料
+  const gridGroupPositionFn$ = gridGroupPositionFnObservable({
+    fullDataFormatter$,
+    gridAxesSize$: gridAxesSize$,
+    computedData$: computedData$,
+    fullChartParams$: fullChartParams$
+  })
+
+  const highlightTarget$ = fullChartParams$.pipe(
+    takeUntil(destroy$),
+    map(d => d.highlightTarget),
+    distinctUntilChanged()
+  )
+  
+  const graphSubscription = combineLatest({
+    seriesLabels: seriesLabels$,
+    computedData: computedData$,
+    SeriesDataMap: SeriesDataMap$,
+    GroupDataMap: GroupDataMap$,
+    linePath: linePath$,
+    params: fullParams$,
+    highlightTarget: highlightTarget$,
+    gridGroupPositionFn: gridGroupPositionFn$,
+  }).pipe(
+    takeUntil(destroy$),
+    // 轉換後會退訂前一個未完成的訂閱事件，因此可以取到「同時間」最後一次的訂閱事件
+    switchMap(async (d) => d),
+  ).subscribe(data => {
+
+    const updateGraphic = graphicGSelection
+      .selectAll<SVGGElement, number>('g')
+      .data(data.seriesLabels, (d, i) => d)
+    const enterGraphic = updateGraphic.enter()
+      .append('g')
+      .classed(gClassName, true)
+    updateGraphic.exit().remove()
+    const graphicSelection = updateGraphic.merge(enterGraphic)
+      .attr('clip-path', (d, i) => `url(#orbcharts__clipPath_${d})`)
+
+    // 繪圖
+    graphicSelection.each((d, i, all) => {
+      // 將資料分段
+      const segmentData = makeSegmentData(data.computedData[i] ?? [])
+
+      const pathSelection = renderLine({
+        selection: d3.select(all[i]),
+        linePath: data.linePath,
+        segmentData: segmentData,
+        params: data.params
+      })
+
+      pathSelection
+        .on('mouseover', (event, datum) => {
+          event.stopPropagation()
+
+          const seriesLabel = datum[0] ? datum[0].seriesLabel : ''
+          const { groupIndex, groupLabel } = data.gridGroupPositionFn(event)
+          const groupData = data.GroupDataMap.get(groupLabel)!
+          const targetDatum = groupData.find(d => d.seriesLabel === seriesLabel)
+          const _datum = targetDatum ?? datum[0]
+    
+          event$.next({
+            type: 'grid',
+            eventName: 'mouseover',
+            pluginName,
+            highlightTarget: data.highlightTarget,
+            datum: _datum,
+            series: data.SeriesDataMap.get(_datum.seriesLabel)!,
+            seriesIndex: _datum.seriesIndex,
+            seriesLabel: _datum.seriesLabel,
+            groups: data.GroupDataMap.get(_datum.groupLabel)!,
+            groupIndex: _datum.groupIndex,
+            groupLabel: _datum.groupLabel,
+            event,
+            data: data.computedData
+          })
+        })
+        .on('mousemove', (event, datum) => {
+          event.stopPropagation()
+
+          const seriesLabel = datum[0] ? datum[0].seriesLabel : ''
+          const { groupIndex, groupLabel } = data.gridGroupPositionFn(event)
+          const groupData = data.GroupDataMap.get(groupLabel)!
+          const targetDatum = groupData.find(d => d.seriesLabel === seriesLabel)
+          const _datum = targetDatum ?? datum[0]
+    
+          event$.next({
+            type: 'grid',
+            eventName: 'mousemove',
+            pluginName,
+            highlightTarget: data.highlightTarget,
+            datum: _datum,
+            series: data.SeriesDataMap.get(_datum.seriesLabel)!,
+            seriesIndex: _datum.seriesIndex,
+            seriesLabel: _datum.seriesLabel,
+            groups: data.GroupDataMap.get(_datum.groupLabel)!,
+            groupIndex: _datum.groupIndex,
+            groupLabel: _datum.groupLabel,
+            event,
+            data: data.computedData
+          })
+        })
+        .on('mouseout', (event, datum) => {
+          event.stopPropagation()
+
+          const seriesLabel = datum[0] ? datum[0].seriesLabel : ''
+          const { groupIndex, groupLabel } = data.gridGroupPositionFn(event)
+          const groupData = data.GroupDataMap.get(groupLabel)!
+          const targetDatum = groupData.find(d => d.seriesLabel === seriesLabel)
+          const _datum = targetDatum ?? datum[0]
+    
+          event$.next({
+            type: 'grid',
+            eventName: 'mouseout',
+            pluginName,
+            highlightTarget: data.highlightTarget,
+            datum: _datum,
+            series: data.SeriesDataMap.get(_datum.seriesLabel)!,
+            seriesIndex: _datum.seriesIndex,
+            seriesLabel: _datum.seriesLabel,
+            groups: data.GroupDataMap.get(_datum.groupLabel)!,
+            groupIndex: _datum.groupIndex,
+            groupLabel: _datum.groupLabel,
+            event,
+            data: data.computedData
+          })
+        })
+        .on('click', (event, datum) => {
+          event.stopPropagation()
+
+          const seriesLabel = datum[0] ? datum[0].seriesLabel : ''
+          const { groupIndex, groupLabel } = data.gridGroupPositionFn(event)
+          const groupData = data.GroupDataMap.get(groupLabel)!
+          const targetDatum = groupData.find(d => d.seriesLabel === seriesLabel)
+          const _datum = targetDatum ?? datum[0]
+    
+          event$.next({
+            type: 'grid',
+            eventName: 'click',
+            pluginName,
+            highlightTarget: data.highlightTarget,
+            datum: _datum,
+            series: data.SeriesDataMap.get(_datum.seriesLabel)!,
+            seriesIndex: _datum.seriesIndex,
+            seriesLabel: _datum.seriesLabel,
+            groups: data.GroupDataMap.get(_datum.groupLabel)!,
+            groupIndex: _datum.groupIndex,
+            groupLabel: _datum.groupLabel,
+            event,
+            data: data.computedData
+          })
+        })
+
+    })
+
+    
+
+    graphicSelection$.next(graphicSelection)
+
+
+    // pathSelection = renderLine({
+    //   selection: graphicSelection,
+    //   linePath: d.linePath,
+    //   data: d.computedData
+    // })
+  })
+
+  // const datumList$ = computedData$.pipe(
+  //   takeUntil(destroy$),
+  //   map(d => d.flat())
+  // )
+  // const highlight$ = highlightObservable({ datumList$, fullChartParams$, event$: store.event$ })
+  const highlightSubscription = gridHighlight$.subscribe()
+  
+  fullChartParams$.pipe(
+    takeUntil(destroy$),
+    filter(d => d.highlightTarget === 'series'),
+    switchMap(d => combineLatest({
+      graphicSelection: graphicSelection$,
+      highlight: gridHighlight$,
+      DataMap: DataMap$,
+      fullChartParams: fullChartParams$
+    }).pipe(
+      takeUntil(destroy$),
+      switchMap(async d => d)
+    ))
+  ).subscribe(data => {
+    const datum = data.DataMap.get(data.highlight[0])
+    // if (!datum) {
+    //   return
+    // }
+    highlightLine({
+      selection: data.graphicSelection,
+      seriesLabel: (datum && datum.seriesLabel) ? datum.seriesLabel : null,
+      fullChartParams: data.fullChartParams
+    })
+  })
+
+  return () => {
+    destroy$.next(undefined)
+    highlightSubscription.unsubscribe()
+  }
+}

package/src/base/types.ts

@@ -1,3 +1,3 @@
-export interface BasePluginFn {
-  (pluginName: string, context: any): () => void // return unsubscribe function
+export interface BasePluginFn<Context> {
+  (pluginName: string, context: Context): () => void // return unsubscribe function
 }