@graphenedata/cli 0.0.1

package/dist/ui/component-utilities/getSeriesConfig.js

@@ -0,0 +1,236 @@
+import getDistinctValues from './getDistinctValues.js'
+import {fmt} from './formatting.js'
+
+export default function getSeriesConfig (
+  data,
+  x,
+  y,
+  series,
+  swapXY,
+  baseConfig,
+  name,
+  xMismatch, // this checks for scenarios where xType is string and xDataType is number. When this is the case, we need to inject strings into the x axis, or else it will cause echarts to think there are duplicate x-axis values (e.g., "4" and 4)
+  columnSummary,
+  seriesOrder,
+  size = undefined,
+  tooltipTitle = undefined,
+  y2 = undefined,
+  seriesLabelFmt = undefined,
+) {
+  function generateTempConfig (seriesData, seriesName, yAxisIndex, baseConfig) {
+    let tempConfig = {
+      name: seriesName,
+      data: seriesData,
+      yAxisIndex: yAxisIndex,
+    }
+    tempConfig = {...baseConfig, ...tempConfig}
+    return tempConfig
+  }
+
+  let i
+  let j
+  let tempConfig
+  let seriesConfig = []
+  let seriesData
+  let filteredData
+  let seriesName
+  let seriesDistinct
+  let yAxisIndex
+
+  // y = single, y2 = empty
+  // y = single, y2 = single
+  // y = single, y2 = array
+
+  // y = array, y2 = empty
+  // y = array, y2 = single
+  // y = array, y2 = array
+
+  // y = empty, y2 = empty
+  // y = empty, y2 = single
+  // y = empty, y2 = array
+
+  // colname, yAxisIndex
+
+  function combineVariables (variable1, variable2) {
+    // Returns an array of arrays, where each individual array is [column_name, yAxisIndex], where yAxisIndex is 0 for y and 1 for y2.
+    // E.g., [ ['sales', 0 ], ['gross_profit', 1]] - sales on primary axis, gross profit on secondary
+    let array = []
+
+    // Helper function to check if a value is undefined
+    function isUndefined (value) {
+      return typeof value === 'undefined'
+    }
+
+    // Helper function to add non-undefined values to the array with source indicator
+    function addValuesToArray (value, source) {
+      if (!isUndefined(value)) {
+        if (Array.isArray(value)) {
+          value.forEach((item) => array.push([item, source]))
+        } else {
+          array.push([value, source])
+        }
+      }
+    }
+
+    addValuesToArray(variable1, 0)
+    addValuesToArray(variable2, 1)
+
+    return array
+  }
+
+  let yList = combineVariables(y, y2)
+
+  // 1) Series column with single y column
+  if (series != null && yList.length === 1) {
+    seriesDistinct = getDistinctValues(data, series)
+
+    for (i = 0; i < seriesDistinct.length; i++) {
+      // Filter for specific series:
+      filteredData = data.filter((d) => d[series] === seriesDistinct[i])
+
+      if (swapXY) {
+        seriesData = filteredData.map((d) => [d[yList[0][0]], xMismatch ? d[x].toString() : d[x]])
+      } else {
+        seriesData = filteredData.map((d) => [xMismatch ? d[x].toString() : d[x], d[yList[0][0]]])
+      }
+
+      // Append size column if supplied (for bubble chart):
+      if (size) {
+        let sizeData = filteredData.map((d) => d[size])
+        seriesData.forEach((item, index) => item.push(sizeData[index]))
+      }
+
+      // Append tooltip label if supplied:
+      if (tooltipTitle) {
+        let tooltipData = filteredData.map((d) => d[tooltipTitle])
+        seriesData.forEach((item, index) => item.push(tooltipData[index]))
+      }
+
+      // Set series name:
+      seriesName = seriesDistinct[i] ?? 'null'
+
+      // Set y-axis index (used for multi-y axis charts):
+      yAxisIndex = yList[0][1]
+
+      tempConfig = generateTempConfig(seriesData, seriesName, yAxisIndex, baseConfig)
+      seriesConfig.push(tempConfig)
+    }
+  }
+
+  // 2) Series column with multiple y columns
+  if (series != null && yList.length > 1) {
+    seriesDistinct = getDistinctValues(data, series)
+    for (i = 0; i < seriesDistinct.length; i++) {
+      // Filter for specific series:
+      filteredData = data.filter((d) => d[series] === seriesDistinct[i])
+
+      for (j = 0; j < yList.length; j++) {
+        if (swapXY) {
+          seriesData = filteredData.map((d) => [
+            d[yList[j][0]],
+            xMismatch ? d[x].toString() : d[x],
+          ])
+        } else {
+          seriesData = filteredData.map((d) => [
+            xMismatch ? d[x].toString() : d[x],
+            d[yList[j][0]],
+          ])
+        }
+
+        // Append size column if supplied (for bubble chart):
+        if (size) {
+          let sizeData = filteredData.map((d) => d[size])
+          seriesData.forEach((item, index) => item.push(sizeData[index]))
+        }
+
+        // Append tooltip label if supplied:
+        if (tooltipTitle) {
+          let tooltipData = filteredData.map((d) => d[tooltipTitle])
+          seriesData.forEach((item, index) => item.push(tooltipData[index]))
+        }
+
+        // Set series name:
+        seriesName = (seriesDistinct[i] ?? 'null') + ' - ' + columnSummary[yList[j][0]].title
+
+        // Set y-axis index (used for multi-y axis charts):
+        yAxisIndex = yList[j][1]
+
+        tempConfig = generateTempConfig(seriesData, seriesName, yAxisIndex, baseConfig)
+        seriesConfig.push(tempConfig)
+      }
+    }
+  }
+
+  // 3) Multiple y columns without series column
+  if (series == null && yList.length > 1) {
+    for (i = 0; i < yList.length; i++) {
+      if (swapXY) {
+        seriesData = data.map((d) => [d[yList[i][0]], xMismatch ? d[x].toString() : d[x]])
+      } else {
+        seriesData = data.map((d) => [xMismatch ? d[x].toString() : d[x], d[yList[i][0]]])
+      }
+
+      // Append size column if supplied (for bubble chart):
+      if (size) {
+        let sizeData = data.map((d) => d[size])
+        seriesData.forEach((item, index) => item.push(sizeData[index]))
+      }
+
+      // Append tooltip label if supplied:
+      if (tooltipTitle) {
+        let tooltipData = data.map((d) => d[tooltipTitle])
+        seriesData.forEach((item, index) => item.push(tooltipData[index]))
+      }
+
+      seriesName = columnSummary[yList[i][0]].title
+
+      // Set y-axis index (used for multi-y axis charts):
+      yAxisIndex = yList[i][1]
+
+      tempConfig = generateTempConfig(seriesData, seriesName, yAxisIndex, baseConfig)
+      seriesConfig.push(tempConfig)
+    }
+  }
+
+  // 4) Single y column without series column
+  if (series == null && yList.length === 1) {
+    if (swapXY) {
+      seriesData = data.map((d) => [d[yList[0][0]], xMismatch ? d[x].toString() : d[x]])
+    } else {
+      seriesData = data.map((d) => [xMismatch ? d[x].toString() : d[x], d[yList[0][0]]])
+    }
+
+    // Append size column if supplied (for bubble chart):
+    if (size) {
+      let sizeData = data.map((d) => d[size])
+      seriesData.forEach((item, index) => item.push(sizeData[index]))
+    }
+
+    // Append tooltip label if supplied:
+    if (tooltipTitle) {
+      let tooltipData = data.map((d) => d[tooltipTitle])
+      seriesData.forEach((item, index) => item.push(tooltipData[index]))
+    }
+
+    seriesName = columnSummary[yList[0][0]].title
+
+    // Set y-axis index (used for multi-y axis charts):
+    yAxisIndex = yList[0][1]
+
+    tempConfig = generateTempConfig(seriesData, seriesName, yAxisIndex, baseConfig)
+    seriesConfig.push(tempConfig)
+  }
+
+  if (seriesOrder) {
+    seriesConfig.sort((a, b) => seriesOrder.indexOf(a.name) - seriesOrder.indexOf(b.name))
+  }
+
+  // format series config:
+  if (seriesLabelFmt) {
+    seriesConfig.forEach((item) => {
+      item.name = fmt(item.name, seriesLabelFmt)
+    })
+  }
+
+  return seriesConfig
+}

package/dist/ui/component-utilities/getSortedData.js

@@ -0,0 +1,7 @@
+export default function getSortedData (data, col, isAsc) {
+  let res = [...data].sort((a, b) => {
+    return (a[col] < b[col] ? -1 : 1) * (isAsc ? 1 : -1)
+  })
+  res._evidenceColumnTypes = data._evidenceColumnTypes
+  return res
+}

package/dist/ui/component-utilities/getStackPercentages.js

@@ -0,0 +1,43 @@
+import {tidy, groupBy, sum, mutateWithSummary, mutate, rate, rename} from '@tidyjs/tidy'
+
+export default function getStackPercentages (data, groupCol, valueCol) {
+  let pctData
+  if (typeof valueCol !== 'object') {
+    pctData = tidy(
+      data,
+      groupBy(groupCol, mutateWithSummary({xTotal: sum(valueCol)})),
+      mutate({percentOfX: rate(valueCol, 'xTotal')}),
+      rename({
+        percentOfX: valueCol + '_pct',
+      }),
+    )
+  } else {
+    pctData = tidy(
+      data,
+      mutate({
+        valueSum: 0,
+      }),
+    )
+
+    for (let i = 0; i < pctData.length; i++) {
+      pctData[i].valueSum = 0
+      for (let j = 0; j < valueCol.length; j++) {
+        pctData[i].valueSum = pctData[i].valueSum + pctData[i][valueCol[j]]
+      }
+    }
+
+    pctData = tidy(pctData, groupBy(groupCol, mutateWithSummary({xTotal: sum('valueSum')})))
+
+    for (let i = 0; i < valueCol.length; i++) {
+      pctData = tidy(
+        pctData,
+        mutate({percentOfX: rate(valueCol[i], 'xTotal')}),
+        rename({
+          percentOfX: valueCol[i] + '_pct',
+        }),
+      )
+    }
+  }
+
+  return pctData
+}

package/dist/ui/component-utilities/getStackedData.js

@@ -0,0 +1,17 @@
+import {tidy, groupBy, summarizeAt, sum} from '@tidyjs/tidy'
+
+export default function getStackedData (data, groupCol, valueCol) {
+  let stackedData = tidy(data, groupBy(groupCol, [summarizeAt(valueCol, sum)]))
+
+  // If multiple y columns, iterate through data and add stack total column for sorting:
+  if (typeof valueCol === 'object') {
+    for (let i = 0; i < stackedData.length; i++) {
+      stackedData[i].stackTotal = 0
+      for (let j = 0; j < valueCol.length; j++) {
+        stackedData[i].stackTotal = stackedData[i].stackTotal + stackedData[i][valueCol[j]]
+      }
+    }
+  }
+
+  return stackedData
+}

package/dist/ui/component-utilities/getYAxisIndex.js

@@ -0,0 +1,15 @@
+// Helper function for multi-series tooltips:
+// Returns the yAxisIndex for a series since we can't currently access that in ECharts' params
+export default function getYAxisIndex (componentIndex, yCount, y2Count) {
+  let totalPatternCount = yCount + y2Count
+
+  // Find the position of the index in the repeating sequence
+  let positionInPattern = componentIndex % totalPatternCount
+
+  // If the position lies within yCount, return 0, otherwise return 1
+  if (positionInPattern < yCount) {
+    return 0
+  } else {
+    return 1
+  }
+}

package/dist/ui/component-utilities/globalContexts.js

@@ -0,0 +1 @@
+export const CUSTOM_FORMATTING_SETTINGS_CONTEXT_KEY = 'customFormattingSettings'

package/dist/ui/component-utilities/helpers/getCompletedData.helpers.js

@@ -0,0 +1,119 @@
+/**
+ * This function is used to find difference between consecutive elements in an array.
+ *
+ * @param {Array<number>} arr - The array from which differences need to be found.
+ * @return {Array<number>} An array containing the differences between consecutive elements.
+ */
+export function getDiffs (arr) {
+  let diffs = []
+  for (let i = 1; i < arr.length; i++) diffs.push(arr[i] - arr[i - 1])
+  return diffs
+}
+
+/**
+ * The function is used to find greatest common divisor (gcd) between two numbers.
+ *
+ * @param {number} a - The first number to find gcd.
+ * @param {number} b - The second number to find gcd.
+ * @return {number} The greatest common divisor of the input numbers a and b.
+ */
+export function gcd (a, b) {
+  // Treat non-numeric types as 0
+  if (typeof a !== 'number' || isNaN(a)) a = 0
+  if (typeof b !== 'number' || isNaN(b)) b = 0
+
+  // Handle negative numbers properly
+  // Never reaches base case w/o this
+  a = Math.abs(a)
+  b = Math.abs(b)
+
+  // base case
+  if (b <= 0.01) {
+    return a
+  } else {
+    return gcd(b, a % b)
+  }
+}
+
+/**
+ * This function is used to find the minimum and maximum values in an array.
+ *
+ * @param {Array} values - An array from which min and max values should be determined.
+ * @param {Function} [valueof] - An optional function that defines how to obtain the measuring value.
+ * @return {Array} An array containing the minimum and maximum of numbers, respectively.
+ */
+export function extent (values, valueof) {
+  if (!Array.isArray(values)) throw new TypeError('Cannot calculate extent of non-array value.')
+  let min
+  let max
+  if (valueof === undefined) {
+    for (let candidate of values) {
+      if (typeof candidate !== 'number' || Number.isNaN(candidate)) continue
+
+      if (min === undefined || candidate < min) min = candidate
+      if (max === undefined || candidate > max) max = candidate
+    }
+    return [min, max]
+  }
+
+  let index = -1
+  for (let original of values) {
+    if (typeof original !== 'number') continue
+    let candidate = valueof(original, ++index, values)
+    if (candidate == null || Number.isNaN(candidate)) continue
+
+    if (min === undefined || candidate < min) min = candidate
+    if (max === undefined || candidate > max) max = candidate
+  }
+  return [min, max]
+}
+
+/**
+ * This function generates a sequence of numbers as a vector from minimum to maximum with the given period increment.
+ *
+ * @param {Array<number>} values - An array containing the data to be sequenced.
+ * @param {number} period - The incremental value for each step in the sequence.
+ * @return {Array<number>} An array containing the sequenced numbers.
+ */
+export function vectorSeq (values, period) {
+  let [min, max] = extent(values)
+
+  let sequence = []
+  let value = min
+  while (value <= max) {
+    sequence.push(Math.round((value + Number.EPSILON) * 100000000) / 100000000)
+    value += period
+  }
+
+  return sequence
+}
+
+/**
+ * This function is used to find the interval distance among numbers in an array.
+ *
+ * @param {Array<number>} arr - An array containing numbers from which interval is calculated.
+ * @return {number|undefined} The interval between numbers in the sorted array, or undefined if the array has only one element.
+ */
+export function findInterval (arr) {
+  if (arr.length <= 1) {
+    return
+  }
+
+  // Sort array ascending
+  arr.sort(function (a, b) {
+    return a - b
+  })
+
+  // 1. Multiply array by 100
+  arr = arr.map(function (x) {
+    return x * 100000000
+  })
+
+  // 2. Get diffs
+  arr = getDiffs(arr)
+
+  // 3. Calculate greatest common divisor of diffs and divide by 100
+  let interval = arr.reduce((a, b) => gcd(a, b)) / 100000000
+  interval = Math.round((interval + Number.EPSILON) * 100000000) / 100000000
+  return interval
+}

package/dist/ui/component-utilities/inputUtils.ts

@@ -0,0 +1,25 @@
+
+export function toBoolean (value: any): boolean {
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'number') return value !== 0
+  if (typeof value === 'string') {
+    let trimmed = value.trim().toLowerCase()
+    if (trimmed === 'true' || trimmed === 'yes' || trimmed === '1') return true
+    if (trimmed === 'false' || trimmed === 'no' || trimmed === '0' || trimmed === '') return false
+  }
+  return Boolean(value)
+}
+
+export function ensureArray<T> (value: T | T[] | undefined | null): T[] {
+  if (Array.isArray(value)) return value
+  if (value === undefined || value === null) return []
+  return [value]
+}
+
+export function serializeValue (value: unknown): string {
+  if (value === null || value === undefined) return 'NULL'
+  if (typeof value === 'number' || typeof value === 'bigint') return String(value)
+  if (typeof value === 'boolean') return value ? 'TRUE' : 'FALSE'
+  let str = String(value)
+  return `'${str.replace(/'/g, "''")}'`
+}

package/dist/ui/component-utilities/replaceNulls.js

@@ -0,0 +1,14 @@
+import {tidy, replaceNully} from '@tidyjs/tidy'
+
+export default function replaceNulls (data, columns) {
+  let colObj = {}
+  if (typeof columns === 'object') {
+    for (let i = 0; i < columns.length; i++) {
+      colObj[columns[i]] = 0
+    }
+  } else {
+    colObj[columns] = 0
+  }
+  data = tidy(data, replaceNully(colObj))
+  return data
+}

package/dist/ui/component-utilities/tableUtils.ts

@@ -0,0 +1,120 @@
+import {strictBuild} from './chartContext.js'
+
+type ColumnSummary = {
+  id: string
+  type?: string
+  format?: any
+  columnUnitSummary?: any
+}
+
+type ColumnOption = {
+  id: string
+}
+
+type ColumnLike = ColumnOption & Partial<ColumnSummary>
+
+export const safeExtractColumn = <T extends ColumnLike>(column: T, columnSummary: ColumnSummary[]): ColumnSummary => {
+  let foundCols = columnSummary.filter(d => d.id === column.id)
+  if (!foundCols.length) {
+    let error = column.id === undefined
+      ? new Error('please add an "id" property to all the <Column ... />')
+      : new Error(`column with id: "${column.id}" not found`)
+    if (strictBuild) throw error
+    console.warn(error.message)
+    return {id: column.id ?? ''}
+  }
+  return foundCols[0]
+}
+
+export const weightedMean = (data: Record<string, unknown>[], valueCol: string, weightCol?: string | null): number | null => {
+  if (!weightCol) return null
+  if (!data.length) return null
+
+  let totalWeightedValue = 0
+  let totalWeight = 0
+
+  for (let item of data) {
+    let value = Number(item[valueCol] ?? 0)
+    let weight = Number(item[weightCol] ?? 0)
+    totalWeightedValue += value * weight
+    totalWeight += weight
+  }
+
+  return totalWeight > 0 ? totalWeightedValue / totalWeight : 0
+}
+
+export const median = (data: Record<string, unknown>[], column: string): number => {
+  let values = data
+    .map(item => item[column])
+    .filter(val => val !== undefined && val !== null && !Number.isNaN(Number(val)))
+    .map(val => Number(val))
+    .sort((a, b) => a - b)
+
+  if (!values.length) return 0
+
+  let mid = Math.floor(values.length / 2)
+  return values.length % 2 !== 0 ? values[mid] : (values[mid - 1] + values[mid]) / 2
+}
+
+export const aggregateColumn = (
+  data: Record<string, unknown>[],
+  columnName: string,
+  aggType: string | undefined,
+  columnType?: string,
+  weightColumnName?: string | null,
+): number | string | null => {
+  if (!data || !data.length) return null
+
+  if (!aggType && columnType === 'number') aggType = 'sum'
+
+  if (
+    columnType !== 'number' &&
+    ['sum', 'min', 'max', 'mean', 'weightedMean', 'median', undefined].includes(aggType as any)
+  ) {
+    return '-'
+  }
+
+  let columnValues = data
+    .map(row => row[columnName])
+    .filter(val => val !== undefined && val !== null)
+    .map(val => Number(val))
+
+  switch (aggType) {
+    case 'sum':
+      return columnValues.reduce((sum, val) => sum + Number(val), 0)
+    case 'min':
+      return Math.min(...columnValues)
+    case 'max':
+      return Math.max(...columnValues)
+    case 'mean':
+      return columnValues.length
+        ? columnValues.reduce((sum, val) => sum + Number(val), 0) / columnValues.length
+        : '-'
+    case 'count':
+      return data.length
+    case 'countDistinct':
+      return new Set(columnValues).size
+    case 'weightedMean':
+      if (!weightColumnName) return 'Weight column name required for weightedMean'
+      let totalWeight = 0
+      let weightedSum = 0
+      for (let row of data) {
+        let weight = Number(row[weightColumnName] ?? 0)
+        totalWeight += weight
+        weightedSum += Number(row[columnName] ?? 0) * weight
+      }
+      return totalWeight > 0 ? weightedSum / totalWeight : null
+    case 'median':
+      return median(data, columnName)
+    case undefined:
+      return '-'
+    default:
+      return aggType ?? '-'
+  }
+}
+
+export const getFinalColumnOrder = (columns: string[], priorityColumns: Array<string | undefined>): string[] => {
+  let priorities = priorityColumns.filter(Boolean) as string[]
+  let restColumns = columns.filter(key => !priorities.includes(key))
+  return [...priorities, ...restColumns]
+}