@buildcanada/charts 0.3.7 → 0.3.8

package/dist/core-table/ChartsTable.js

@@ -0,0 +1,887 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+import * as _ from "lodash-es";
+import {
+  intersectionOfSets,
+  findClosestTimeIndex,
+  sortNumeric,
+  getClosestTimePairs,
+  sortedFindClosest,
+  cagr,
+  makeAnnotationsSlug,
+  isPresent,
+  imemo,
+  ToleranceStrategy,
+  differenceOfSets,
+  sortedFindClosestIndex
+} from "../utils/index.js";
+import {
+  TransformType,
+  ColumnTypeNames,
+  ChartsTableSlugs,
+  ErrorValue
+} from "../types/index.js";
+import { CoreTable } from "./CoreTable.js";
+import { ErrorValueTypes, isNotErrorValue } from "./ErrorValues.js";
+import {
+  getOriginalTimeColumnSlug,
+  makeOriginalValueSlugFromColumnSlug,
+  makeOriginalTimeSlugFromColumnSlug,
+  makeOriginalStartTimeSlugFromColumnSlug,
+  timeColumnSlugFromColumnDef,
+  toPercentageColumnDef
+} from "./TableUtil.js";
+import {
+  linearInterpolation,
+  toleranceInterpolation,
+  replaceDef
+} from "./CoreTableUtils.js";
+import { ColumnTypeMap } from "./CoreTableColumns.js";
+class ChartsTable extends CoreTable {
+  get availableEntityNames() {
+    return Array.from(this.availableEntityNameSet);
+  }
+  get availableEntityNameSet() {
+    return this.entityNameColumn.uniqValuesAsSet;
+  }
+  get entityNameColumn() {
+    return this.getFirstColumnWithType(ColumnTypeNames.EntityName) ?? this.get(ChartsTableSlugs.entityName);
+  }
+  get minTime() {
+    return _.min(this.allTimes);
+  }
+  get maxTime() {
+    return _.max(this.allTimes);
+  }
+  get allTimes() {
+    return this.get(this.timeColumn.slug).values;
+  }
+  get rowIndicesByEntityName() {
+    return this.rowIndex([this.entityNameSlug]);
+  }
+  getAnnotationColumnSlug(columnDef) {
+    return _.isEmpty(columnDef?.annotationsColumnSlug) ? makeAnnotationsSlug(columnDef.slug) : columnDef.annotationsColumnSlug;
+  }
+  // todo: instead of this we should probably make annotations another property on charts—something like "annotationsColumnSlugs"
+  getAnnotationColumnForColumn(columnSlug) {
+    const def = this.get(columnSlug).def;
+    const slug = this.getAnnotationColumnSlug(def);
+    return this.get(slug);
+  }
+  getTimesUniqSortedAscForColumns(columnSlugs) {
+    return sortNumeric(
+      _.uniq(
+        this.getColumns(columnSlugs).filter((col) => col).flatMap((col) => col.uniqTimesAsc)
+      )
+    );
+  }
+  timeDomainFor(slugs) {
+    const cols = this.getColumns(slugs);
+    const mins = cols.map((col) => col.minTime);
+    const maxes = cols.map((col) => col.maxTime);
+    return [_.min(mins), _.max(maxes)];
+  }
+  originalTimeDomainFor(slugs) {
+    const cols = this.getColumns(slugs);
+    const mins = cols.map((col) => _.min(col.originalTimes));
+    const maxes = cols.map((col) => _.max(col.originalTimes));
+    return [_.min(mins), _.max(maxes)];
+  }
+  filterByEntityNames(names) {
+    const namesSet = new Set(names);
+    return this.columnFilter(
+      this.entityNameSlug,
+      (value) => namesSet.has(value),
+      `Filter out all entities except '${names}'`
+    );
+  }
+  filterByEntityNamesUsingIncludeExcludePattern({
+    excluded,
+    included
+  }) {
+    if (!included && !excluded) return this;
+    const excludedSet = new Set(excluded);
+    const includedSet = new Set(included);
+    const excludeFilter = (entityName) => !excludedSet.has(entityName);
+    const includeFilter = includedSet.size > 0 ? (entityName) => includedSet.has(entityName) : () => true;
+    const filterFn = (entityName) => excludeFilter(entityName) && includeFilter(entityName);
+    const excludedList = excluded ? excluded.join(", ") : "";
+    const includedList = included ? included.join(", ") : "";
+    return this.columnFilter(
+      this.entityNameSlug,
+      filterFn,
+      `Excluded entities specified by author: ${excludedList} - Included entities specified by author: ${includedList}`
+    );
+  }
+  get sortedByTime() {
+    if (this.timeColumn.isMissing) return this;
+    return this.sortBy([this.timeColumn.slug]);
+  }
+  filterByTimeRange(start, end) {
+    if (this.isBlank) return this;
+    const adjustedStart = start === Infinity ? this.maxTime : start;
+    const adjustedEnd = end === -Infinity ? this.minTime : end;
+    const timeColumnSlug = this.timeColumn?.slug || ChartsTableSlugs.time;
+    const description = `Keep only rows with Time between ${adjustedStart} - ${adjustedEnd}`;
+    if (adjustedStart <= this.minTime && adjustedEnd >= this.maxTime)
+      return this.noopTransform(description).sortedByTime;
+    return this.columnFilter(
+      timeColumnSlug,
+      (time) => time >= adjustedStart && time <= adjustedEnd,
+      description
+      // Sorting by time, because incidentally some parts of the code depended on this method
+      // returning sorted rows.
+    ).sortedByTime;
+  }
+  filterByTargetTimes(targetTimes, tolerance = 0) {
+    const timeColumn = this.timeColumn;
+    const timeValues = timeColumn.valuesIncludingErrorValues;
+    if (tolerance === 0) {
+      const targetTimesSet = new Set(targetTimes);
+      return this.columnFilter(
+        timeColumn.slug,
+        (time) => targetTimesSet.has(time),
+        `Keep only rows with time equal to one of the target times: ${targetTimes.join(
+          ", "
+        )}`
+      );
+    }
+    const entityNameToIndices = this.rowIndicesByEntityName;
+    const matchingIndices = /* @__PURE__ */ new Set();
+    this.availableEntityNames.forEach((entityName) => {
+      const indices = entityNameToIndices.get(entityName) || [];
+      const allTimesAsc = indices.map((index) => ({ time: timeValues[index], index })).sort((a, b) => a.time - b.time);
+      targetTimes.forEach((targetTime) => {
+        const index = findClosestTimeIndex(
+          allTimesAsc.map((t) => t.time),
+          targetTime,
+          tolerance
+        );
+        const closest = index === void 0 ? void 0 : allTimesAsc[index];
+        if (closest !== void 0) matchingIndices.add(closest.index);
+      });
+    });
+    return this.columnFilter(
+      this.entityNameSlug,
+      (row, index) => matchingIndices.has(index),
+      `Keep a row for each entity for each of the closest times ${targetTimes.join(
+        ", "
+      )} with tolerance ${tolerance}`
+    );
+  }
+  hasAnyColumnNoValidValue(slugs) {
+    return slugs.some((slug) => this.get(slug).numValues === 0);
+  }
+  dropAllRows() {
+    return this.dropRowsAt(this.indices, "Drop all rows");
+  }
+  dropRowsWithErrorValuesForColumn(slug) {
+    return this.columnFilter(
+      slug,
+      (value) => isNotErrorValue(value),
+      `Drop rows with empty or ErrorValues in ${slug} column`
+    );
+  }
+  // TODO rewrite with column ops
+  // TODO move to CoreTable
+  dropRowsWithErrorValuesForAnyColumn(slugs) {
+    return this.rowFilter(
+      (row) => slugs.every((slug) => isNotErrorValue(row[slug])),
+      `Drop rows with empty or ErrorValues in any column: ${slugs.join(
+        ", "
+      )}`
+    );
+  }
+  // TODO rewrite with column ops
+  // TODO move to CoreTable
+  dropRowsWithErrorValuesForAllColumns(slugs) {
+    return this.rowFilter(
+      (row) => slugs.some((slug) => isNotErrorValue(row[slug])),
+      `Drop rows with empty or ErrorValues in every column: ${slugs.join(
+        ", "
+      )}`
+    );
+  }
+  // Drop _all rows_ for an entity if there is any column that has no valid values for that entity.
+  dropEntitiesThatHaveNoDataInSomeColumn(columnSlugs) {
+    const indexesByEntityName = this.rowIndicesByEntityName;
+    const entityNamesToKeep = new Set(indexesByEntityName.keys());
+    for (const slug of columnSlugs) {
+      const col = this.get(slug);
+      if (col.numErrorValues === 0) continue;
+      for (const entityName of entityNamesToKeep) {
+        const indicesForEntityName = indexesByEntityName.get(entityName);
+        if (!indicesForEntityName)
+          throw new Error("Unexpected: entity not found in index map");
+        const hasSomeValidValueForEntityInCol = indicesForEntityName.some(
+          (index) => isNotErrorValue(col.valuesIncludingErrorValues[index])
+        );
+        if (!hasSomeValidValueForEntityInCol)
+          entityNamesToKeep.delete(entityName);
+      }
+    }
+    const entityNamesToDrop = differenceOfSets([
+      this.availableEntityNameSet,
+      entityNamesToKeep
+    ]);
+    const droppedEntitiesStr = entityNamesToDrop.size > 0 ? [...entityNamesToDrop].join(", ") : "(None)";
+    if (entityNamesToDrop.size === 0) {
+      return this.noopTransform(
+        `Drop entities that have no data in some column`
+      );
+    }
+    return this.columnFilter(
+      this.entityNameSlug,
+      (rowEntityName) => entityNamesToKeep.has(rowEntityName),
+      `Drop ${entityNamesToDrop.size} entities that have no data in some column: ${columnSlugs.join(", ")}.
+Dropped entities: ${droppedEntitiesStr}`
+    );
+  }
+  // Drop _all rows_ for an entity if all columns have at least one invalid or missing value for that entity.
+  dropEntitiesThatHaveSomeMissingOrErrorValueInAllColumns(columnSlugs) {
+    const indexesByEntityName = this.rowIndicesByEntityName;
+    const uniqTimes = new Set(this.allTimes);
+    const entityNamesToIterateOver = new Set(indexesByEntityName.keys());
+    const entityNamesToKeep = /* @__PURE__ */ new Set();
+    const entityCount = entityNamesToIterateOver.size;
+    const makeOpName = (entityNamesToKeep2) => {
+      const entityNamesToDrop = differenceOfSets([
+        this.availableEntityNameSet,
+        entityNamesToKeep2
+      ]);
+      const droppedEntitiesStr = entityNamesToDrop.size > 0 ? [...entityNamesToDrop].join(", ") : "(None)";
+      return `Drop entities that have some missing or error value in all column: ${columnSlugs.join(", ")}.
+Dropped entities: ${droppedEntitiesStr}`;
+    };
+    for (const slug of columnSlugs) {
+      const col = this.get(slug);
+      if (col.numValues === entityCount * uniqTimes.size && col.numErrorValues === 0) {
+        const entityNamesToKeep2 = new Set(indexesByEntityName.keys());
+        return this.columnFilter(
+          this.entityNameSlug,
+          (rowEntityName) => entityNamesToKeep2.has(rowEntityName),
+          makeOpName(entityNamesToKeep2)
+        );
+      }
+    }
+    for (const slug of columnSlugs) {
+      const col = this.get(slug);
+      for (const entityName of entityNamesToIterateOver) {
+        const indicesForEntityName = indexesByEntityName.get(entityName);
+        if (!indicesForEntityName)
+          throw new Error("Unexpected: entity not found in index map");
+        if (indicesForEntityName.length < uniqTimes.size) continue;
+        const hasSomeInvalidValueForEntityInCol = indicesForEntityName.some(
+          (index) => !isNotErrorValue(
+            col.valuesIncludingErrorValues[index]
+          )
+        );
+        if (!hasSomeInvalidValueForEntityInCol) {
+          entityNamesToKeep.add(entityName);
+          entityNamesToIterateOver.delete(entityName);
+        }
+      }
+    }
+    return this.columnFilter(
+      this.entityNameSlug,
+      (rowEntityName) => entityNamesToKeep.has(rowEntityName),
+      makeOpName(entityNamesToKeep)
+    );
+  }
+  sumsByTime(columnSlug) {
+    const timeValues = this.timeColumn.values;
+    const values = this.get(columnSlug).values;
+    if (timeValues.length !== values.length)
+      throw Error(
+        `Tried to run sumsByTime when timeValues (${timeValues.length}) and values (${values.length}) had different length`
+      );
+    const map = /* @__PURE__ */ new Map();
+    timeValues.forEach(
+      (time, index) => map.set(time, (map.get(time) ?? 0) + values[index])
+    );
+    return map;
+  }
+  // todo: this needs tests (and/or drop in favor of someone else's package)
+  // Shows how much each entity contributed to the given column for each time period
+  toPercentageFromEachEntityForEachTime(columnSlug) {
+    if (!this.has(columnSlug)) return this;
+    const timeColumn = this.timeColumn;
+    const col = this.get(columnSlug);
+    const timeTotals = this.sumsByTime(columnSlug);
+    const timeValues = timeColumn.values;
+    const newDefs = replaceDef(this.defs, [
+      toPercentageColumnDef(col.def, ColumnTypeNames.RelativePercentage)
+    ]);
+    const newColumnStore = {
+      ...this.columnStore,
+      [columnSlug]: this.columnStore[columnSlug].map((val, index) => {
+        const timeTotal = timeTotals.get(timeValues[index]);
+        if (timeTotal === 0) return ErrorValueTypes.DivideByZeroError;
+        return 100 * val / timeTotal;
+      })
+    };
+    return this.transform(
+      newColumnStore,
+      newDefs,
+      `Transformed ${columnSlug} column to be % contribution of each entity for that time`,
+      TransformType.UpdateColumnDefsAndApply
+    );
+  }
+  // If you want to see how much each column contributed to the entity for that year, use this.
+  // NB: Uses absolute value. So if one entity added 100, and another -100, they both would have contributed "50%" to that year.
+  // Otherwise we'd have NaN.
+  toPercentageFromEachColumnForEachEntityAndTime(columnSlugs) {
+    columnSlugs = columnSlugs.filter((slug) => this.has(slug));
+    if (!columnSlugs.length) return this;
+    const newDefs = this.defs.map((def) => {
+      if (columnSlugs.includes(def.slug))
+        return toPercentageColumnDef(
+          def,
+          ColumnTypeNames.RelativePercentage
+        );
+      return def;
+    });
+    const columnStore = this.columnStore;
+    const columnStorePatch = {};
+    const totals = new Array(this.numRows).fill(0).map(
+      (__, i) => _.sumBy(columnSlugs, (slug) => {
+        const value = columnStore[slug][i];
+        return _.isNumber(value) ? Math.abs(value) : 0;
+      })
+    );
+    columnSlugs.forEach((slug) => {
+      columnStorePatch[slug] = columnStore[slug].map((value, i) => {
+        const total = totals[i];
+        if (!_.isNumber(value) || !_.isNumber(total)) return value;
+        if (total === 0) return ErrorValueTypes.DivideByZeroError;
+        return 100 * Math.abs(value) / total;
+      });
+    });
+    const newColumnStore = {
+      ...columnStore,
+      ...columnStorePatch
+    };
+    return this.transform(
+      newColumnStore,
+      newDefs,
+      `Transformed columns from absolute numbers to % of abs sum of ${columnSlugs.join(
+        ","
+      )} `,
+      TransformType.UpdateColumnDefs
+    );
+  }
+  // todo: this needs tests (and/or drop in favor of someone else's package)
+  // If you wanted to build a table showing something like GDP growth relative to 1950, use this.
+  toTotalGrowthForEachColumnComparedToStartTime(startTimeBound, columnSlugs) {
+    if (this.timeColumn.isMissing) return this;
+    const timeColumnSlug = this.timeColumn.slug;
+    const newDefs = this.defs.map((def) => {
+      if (columnSlugs.includes(def.slug))
+        return toPercentageColumnDef(
+          def,
+          ColumnTypeNames.PercentChangeOverTime
+        );
+      return def;
+    });
+    const newRows = Object.values(
+      _.groupBy(this.sortedByTime.rows, (row) => row[this.entityNameSlug])
+    ).flatMap((rowsForSingleEntity) => {
+      columnSlugs.forEach((valueSlug) => {
+        let comparisonValue;
+        rowsForSingleEntity = rowsForSingleEntity.map(
+          (row) => {
+            const newRow = {
+              ...row
+            };
+            const value = row[valueSlug];
+            if (row[timeColumnSlug] < startTimeBound) {
+              newRow[valueSlug] = ErrorValueTypes.MissingValuePlaceholder;
+            } else if (!_.isNumber(value)) {
+              newRow[valueSlug] = ErrorValueTypes.NaNButShouldBeNumber;
+            } else if (comparisonValue !== void 0) {
+              newRow[valueSlug] = 100 * (value - comparisonValue) / Math.abs(comparisonValue);
+            } else if (value === 0) {
+              newRow[valueSlug] = ErrorValueTypes.MissingValuePlaceholder;
+            } else {
+              comparisonValue = value;
+              newRow[valueSlug] = 0;
+            }
+            return newRow;
+          }
+        );
+      });
+      return rowsForSingleEntity;
+    });
+    return this.transform(
+      newRows,
+      newDefs,
+      `Transformed columns from absolute values to % of time ${startTimeBound} for columns ${columnSlugs.join(
+        ","
+      )} `,
+      TransformType.UpdateColumnDefs
+    );
+  }
+  keepMinTimeAndMaxTimeForEachEntityOnly() {
+    const indexMap = this.rowIndicesByEntityName;
+    const timeColumn = this.timeColumn;
+    if (timeColumn.isMissing) return this;
+    const timeValues = timeColumn.valuesIncludingErrorValues;
+    const matchingIndices = /* @__PURE__ */ new Set();
+    indexMap.forEach(
+      (indices) => [_.minBy, _.maxBy].map((f) => f(indices, (index) => timeValues[index])).filter(isPresent).forEach((index) => matchingIndices.add(index))
+    );
+    return this.columnFilter(
+      timeColumn.slug,
+      (row, index) => matchingIndices.has(index),
+      `Keep minTime & maxTime rows only for each entity`
+    );
+  }
+  getAverageAnnualChangeIndicesByEntity(columnSlugs) {
+    const columns = columnSlugs.map((slug) => this.get(slug));
+    const indexMap = this.rowIndicesByEntityName;
+    const timeValues = this.timeColumn.valuesIncludingErrorValues;
+    const entityNameToIndices = /* @__PURE__ */ new Map();
+    indexMap.forEach((indices, entityName) => {
+      const nonZeroValueIndices = indices.filter(
+        (index) => columns.every((col) => {
+          const value = col.valuesIncludingErrorValues[index];
+          return _.isNumber(value) && value !== 0;
+        })
+      );
+      const minIndex = _.minBy(
+        nonZeroValueIndices,
+        (index) => timeValues[index]
+      );
+      const maxIndex = _.maxBy(indices, (index) => timeValues[index]);
+      if (minIndex === void 0 || maxIndex === void 0) return;
+      const allValuePairsHaveDistinctTime = columns.every((col) => {
+        const originalTimes = this.columnStore[col.originalTimeColumnSlug];
+        return originalTimes[minIndex] !== originalTimes[maxIndex];
+      });
+      if (allValuePairsHaveDistinctTime)
+        entityNameToIndices.set(entityName, [minIndex, maxIndex]);
+    });
+    return entityNameToIndices;
+  }
+  toAverageAnnualChangeForEachEntity(columnSlugs) {
+    columnSlugs = columnSlugs.filter((slug) => this.has(slug));
+    if (this.timeColumn.isMissing || !(this.timeColumn instanceof ColumnTypeMap.Year) || columnSlugs.length === 0)
+      return this;
+    const columns = columnSlugs.map((slug) => this.get(slug));
+    const entityNameToIndices = this.getAverageAnnualChangeIndicesByEntity(columnSlugs);
+    const rows = [];
+    entityNameToIndices.forEach((indices) => {
+      const [startRow, endRow] = this.rowsAt(indices);
+      const newRow = { ...endRow };
+      columns.forEach((col) => {
+        const timeSlug = col.originalTimeColumnSlug;
+        const startTime = startRow[timeSlug];
+        const endTime = endRow[timeSlug];
+        const yearsElapsed = endTime - startTime;
+        const startValue = startRow[col.slug];
+        const endValue = endRow[col.slug];
+        newRow[col.slug] = cagr(startValue, endValue, yearsElapsed);
+        const startTimeSlug = makeOriginalStartTimeSlugFromColumnSlug(
+          col.slug
+        );
+        newRow[startTimeSlug] = startTime;
+      });
+      rows.push(newRow);
+    });
+    const newDefs = [
+      ...replaceDef(
+        this.defs,
+        columns.map(
+          (col) => toPercentageColumnDef(
+            col.def,
+            ColumnTypeNames.PercentChangeOverTime
+          )
+        )
+      ),
+      ...columns.map((col) => {
+        return {
+          ...this.timeColumn.def,
+          slug: makeOriginalStartTimeSlugFromColumnSlug(col.slug)
+        };
+      })
+    ];
+    return this.transform(
+      rows,
+      newDefs,
+      `Average annual change for columns: ${columnSlugs.join(", ")}`,
+      TransformType.UpdateRows
+    );
+  }
+  // Give our users a clean CSV of each Grapher. Assumes a ChartsTable with entityName.
+  toPrettyCsv(useShortNames = false, activeColumnSlugs = void 0) {
+    let table;
+    if (activeColumnSlugs?.length) {
+      const timeColumnToInclude = [
+        ChartsTableSlugs.year,
+        ChartsTableSlugs.day,
+        this.timeColumn.slug
+        // needed for explorers, where the time column may be called anything
+      ].find((colSlug) => this.has(colSlug));
+      if (!timeColumnToInclude)
+        throw new Error(
+          "Expected to find a time column to include in the CSV"
+        );
+      table = this.select([
+        timeColumnToInclude,
+        this.entityNameSlug,
+        ...activeColumnSlugs
+      ]);
+    } else {
+      table = this.dropColumns([
+        ChartsTableSlugs.entityId,
+        ChartsTableSlugs.time,
+        ChartsTableSlugs.entityColor
+      ]);
+    }
+    return table.sortBy([this.entityNameSlug]).toCsvWithColumnNames(useShortNames);
+  }
+  get entityNameColorIndex() {
+    return this.valueIndex(
+      this.entityNameSlug,
+      ChartsTableSlugs.entityColor
+    );
+  }
+  getColorForEntityName(entityName) {
+    return this.entityNameColorIndex.get(entityName);
+  }
+  get columnDisplayNameToColorMap() {
+    return new Map(
+      this.columnsAsArray.filter((col) => col.def.color).map((col) => [col.displayName, col.def.color])
+    );
+  }
+  // This assumes the table is sorted where the times for entity names go in asc order.
+  // The whole table does not have to be sorted by time.
+  getLatestValueForEntity(entityName, columnSlug) {
+    const indices = this.rowIndicesByEntityName.get(entityName);
+    if (!indices) return void 0;
+    const values = this.get(columnSlug).valuesIncludingErrorValues;
+    const descending = indices.toReversed();
+    const index = descending.find(
+      (index2) => !(values[index2] instanceof ErrorValue)
+    );
+    return index !== void 0 ? values[index] : void 0;
+  }
+  entitiesWith(columnSlugs) {
+    if (!columnSlugs.length) return /* @__PURE__ */ new Set();
+    if (columnSlugs.length === 1)
+      return new Set(this.get(columnSlugs[0]).uniqEntityNames);
+    return intersectionOfSets(
+      columnSlugs.map((slug) => new Set(this.get(slug).uniqEntityNames))
+    );
+  }
+  // Retrieves the two columns `columnSlug` and `timeColumnSlug` from the table and
+  // passes their values to the respective interpolation method.
+  // `withAllRows` is expected to be completed and sorted.
+  interpolate(withAllRows, columnSlug, timeColumnSlug, interpolation, context) {
+    const groupBoundaries = withAllRows.groupBoundaries(this.entityNameSlug);
+    const col = withAllRows.get(columnSlug);
+    const validIndices = col.validRowIndices;
+    const newValues = col.valuesIncludingErrorValues.slice();
+    const newTimes = withAllRows.get(timeColumnSlug).valuesIncludingErrorValues.slice();
+    groupBoundaries.forEach((_2, index) => {
+      interpolation(
+        newValues,
+        newTimes,
+        validIndices,
+        context,
+        groupBoundaries[index],
+        groupBoundaries[index + 1]
+      );
+    });
+    return {
+      values: newValues,
+      times: newTimes
+    };
+  }
+  // TODO generalize `interpolateColumnWithTolerance` and `interpolateColumnLinearly` more
+  // There are finicky details in both of them that complicate this
+  interpolateColumnWithTolerance(columnSlug, { toleranceStrategyOverride, toleranceOverride } = {}) {
+    if (!this.has(columnSlug)) return this;
+    const column = this.get(columnSlug);
+    const columnDef = column.def;
+    const tolerance = toleranceOverride ?? column.tolerance ?? 0;
+    const toleranceStrategy = toleranceStrategyOverride ?? column.toleranceStrategy ?? ToleranceStrategy.closest;
+    const timeColumnOfTable = !this.timeColumn.isMissing ? this.timeColumn : (
+      // CovidTable does not have a day or year column so we need to use time.
+      this.get(ChartsTableSlugs.time)
+    );
+    const maybeTimeColumnOfValue = getOriginalTimeColumnSlug(this, columnSlug) ?? timeColumnSlugFromColumnDef(columnDef);
+    const timeColumnOfValue = this.get(maybeTimeColumnOfValue);
+    const originalTimeSlug = makeOriginalTimeSlugFromColumnSlug(columnSlug);
+    let columnStore;
+    if (tolerance) {
+      const withAllRows = this.complete([
+        this.entityNameSlug,
+        timeColumnOfTable.slug
+      ]).sortBy([this.entityNameSlug, timeColumnOfTable.slug]);
+      const interpolateInBothDirections = !toleranceStrategy || toleranceStrategy === ToleranceStrategy.closest;
+      const interpolateBackwards = interpolateInBothDirections || toleranceStrategy === ToleranceStrategy.backwards;
+      const interpolateForwards = interpolateInBothDirections || toleranceStrategy === ToleranceStrategy.forwards;
+      const interpolationResult = this.interpolate(
+        withAllRows,
+        columnSlug,
+        timeColumnOfValue.slug,
+        toleranceInterpolation,
+        {
+          timeToleranceBackwards: interpolateBackwards ? tolerance : 0,
+          timeToleranceForwards: interpolateForwards ? tolerance : 0
+        }
+      );
+      columnStore = {
+        ...withAllRows.columnStore,
+        [columnSlug]: interpolationResult.values,
+        [originalTimeSlug]: interpolationResult.times
+      };
+    } else {
+      columnStore = {
+        ...this.columnStore,
+        [originalTimeSlug]: timeColumnOfValue.valuesIncludingErrorValues
+      };
+    }
+    return this.transform(
+      columnStore,
+      [
+        ...this.defs,
+        {
+          ...timeColumnOfValue.def,
+          slug: originalTimeSlug,
+          display: {
+            includeInTable: false
+          }
+        }
+      ],
+      `Interpolated values in column ${columnSlug} with tolerance ${tolerance} and appended column ${originalTimeSlug} with the original times`,
+      TransformType.UpdateColumnDefs
+    );
+  }
+  interpolateColumnLinearly(columnSlug, extrapolate = false) {
+    if (!this.has(columnSlug)) return this;
+    const column = this.get(columnSlug);
+    const columnDef = column?.def;
+    const maybeTimeColumnSlug = getOriginalTimeColumnSlug(this, columnSlug) ?? timeColumnSlugFromColumnDef(columnDef);
+    const timeColumn = this.get(maybeTimeColumnSlug) ?? this.get(ChartsTableSlugs.time);
+    const originalColumnSlug = makeOriginalValueSlugFromColumnSlug(columnSlug);
+    const originalColumnDef = {
+      ...columnDef,
+      slug: originalColumnSlug,
+      display: { includeInTable: false }
+    };
+    const withAllRows = this.complete([
+      this.entityNameSlug,
+      timeColumn.slug
+    ]).sortBy([this.entityNameSlug, timeColumn.slug]);
+    const interpolationResult = this.interpolate(
+      withAllRows,
+      columnSlug,
+      timeColumn.slug,
+      linearInterpolation,
+      { extrapolateAtStart: extrapolate, extrapolateAtEnd: extrapolate }
+    );
+    const columnStore = {
+      ...withAllRows.columnStore,
+      [originalColumnSlug]: withAllRows.columnStore[columnSlug],
+      [columnSlug]: interpolationResult.values
+    };
+    return this.transform(
+      columnStore,
+      [
+        ...this.defs,
+        originalColumnDef,
+        {
+          ...timeColumn.def
+        }
+      ],
+      `Interpolated values in column ${columnSlug} linearly and appended column ${originalColumnSlug} with the original values`,
+      TransformType.UpdateColumnDefs
+    );
+  }
+  interpolateColumnsByClosestTimeMatch(columnSlugA, columnSlugB) {
+    if (!this.has(columnSlugA) || !this.has(columnSlugB)) return this;
+    const columnA = this.get(columnSlugA);
+    const columnB = this.get(columnSlugB);
+    const toleranceA = columnA.tolerance ?? 0;
+    const toleranceB = columnB.tolerance ?? 0;
+    if (this.timeColumn.isMissing || this.timeColumn.slug !== columnA.originalTimeColumnSlug || this.timeColumn.slug !== columnB.originalTimeColumnSlug || toleranceA === 0 && toleranceB === 0) {
+      return this;
+    }
+    const maxDiff = Math.max(toleranceA, toleranceB);
+    const withAllRows = this.complete([
+      this.entityNameSlug,
+      this.timeColumn.slug
+    ]).sortBy([this.entityNameSlug, this.timeColumn.slug]);
+    const valuesA = withAllRows.get(columnA.slug).valuesIncludingErrorValues;
+    const valuesB = withAllRows.get(columnB.slug).valuesIncludingErrorValues;
+    const times = withAllRows.timeColumn.valuesIncludingErrorValues;
+    const newValuesA = new Array(times.length).fill(
+      ErrorValueTypes.NoValueWithinTolerance
+    );
+    const newValuesB = new Array(times.length).fill(
+      ErrorValueTypes.NoValueWithinTolerance
+    );
+    const newTimesA = new Array(times.length).fill(
+      ErrorValueTypes.NoValueWithinTolerance
+    );
+    const newTimesB = new Array(times.length).fill(
+      ErrorValueTypes.NoValueWithinTolerance
+    );
+    const groupBoundaries = withAllRows.groupBoundaries(this.entityNameSlug);
+    for (let i = 1; i < groupBoundaries.length; i++) {
+      const startIndex = groupBoundaries[i - 1];
+      const endIndex = groupBoundaries[i];
+      const numRows = endIndex - startIndex;
+      const availableTimesA = [];
+      const availableTimesB = [];
+      for (let index = startIndex; index < endIndex; index++) {
+        if (isNotErrorValue(valuesA[index]))
+          availableTimesA.push(times[index]);
+        if (isNotErrorValue(valuesB[index]))
+          availableTimesB.push(times[index]);
+      }
+      if (availableTimesA.length === 0 || availableTimesB.length === 0) {
+        continue;
+      }
+      if (availableTimesA.length === numRows && availableTimesB.length === numRows) {
+        for (let index = startIndex; index < endIndex; index++) {
+          newValuesA[index] = valuesA[index];
+          newValuesB[index] = valuesB[index];
+          newTimesA[index] = times[index];
+          newTimesB[index] = times[index];
+        }
+        continue;
+      }
+      const timePairs = getClosestTimePairs(
+        availableTimesA,
+        availableTimesB,
+        maxDiff
+      );
+      const timeAtoTimeB = new Map(timePairs);
+      const pairedTimesInA = sortNumeric(
+        Array.from(timeAtoTimeB.keys())
+      );
+      for (let index = startIndex; index < endIndex; index++) {
+        const currentTime = times[index];
+        const candidateTimeA = sortedFindClosest(
+          pairedTimesInA,
+          currentTime
+        );
+        if (candidateTimeA === void 0) continue;
+        if (Math.abs(currentTime - candidateTimeA) > toleranceA)
+          continue;
+        const candidateTimeB = timeAtoTimeB.get(candidateTimeA);
+        if (candidateTimeB === void 0 || Math.abs(currentTime - candidateTimeB) > toleranceB) {
+          continue;
+        }
+        const candidateIndexA = sortedFindClosestIndex(
+          times,
+          candidateTimeA,
+          startIndex,
+          endIndex
+        );
+        const candidateIndexB = sortedFindClosestIndex(
+          times,
+          candidateTimeB,
+          startIndex,
+          endIndex
+        );
+        newValuesA[index] = valuesA[candidateIndexA];
+        newValuesB[index] = valuesB[candidateIndexB];
+        newTimesA[index] = times[candidateIndexA];
+        newTimesB[index] = times[candidateIndexB];
+      }
+    }
+    const originalTimeColumnASlug = makeOriginalTimeSlugFromColumnSlug(
+      columnA.slug
+    );
+    const originalTimeColumnBSlug = makeOriginalTimeSlugFromColumnSlug(
+      columnB.slug
+    );
+    const columnStore = {
+      ...withAllRows.columnStore,
+      [columnA.slug]: newValuesA,
+      [columnB.slug]: newValuesB,
+      [originalTimeColumnASlug]: newTimesA,
+      [originalTimeColumnBSlug]: newTimesB
+    };
+    return withAllRows.transform(
+      columnStore,
+      [
+        ...withAllRows.defs,
+        {
+          ...withAllRows.timeColumn.def,
+          slug: originalTimeColumnASlug
+        },
+        {
+          ...withAllRows.timeColumn.def,
+          slug: originalTimeColumnBSlug
+        }
+      ],
+      `Interpolated values`,
+      TransformType.UpdateColumnDefs
+    );
+  }
+  sampleEntityName(howMany = 1) {
+    return this.availableEntityNames.slice(0, howMany);
+  }
+  get isBlank() {
+    return !this.numRows;
+  }
+}
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "availableEntityNames", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "availableEntityNameSet", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "entityNameColumn", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "minTime", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "maxTime", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "allTimes", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "rowIndicesByEntityName", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "sortedByTime", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "entityNameColorIndex", 1);
+__decorateClass([
+  imemo
+], ChartsTable.prototype, "columnDisplayNameToColorMap", 1);
+const BLANK_TABLE_MESSAGE = `Table is empty.`;
+const BlankChartsTable = (tableSlug = `blankChartsTable`, extraTableDescription = "") => new ChartsTable(
+  void 0,
+  [
+    { slug: ChartsTableSlugs.entityName },
+    { slug: ChartsTableSlugs.year, type: ColumnTypeNames.Year }
+  ],
+  {
+    tableDescription: BLANK_TABLE_MESSAGE + extraTableDescription,
+    tableSlug
+  }
+);
+export {
+  BlankChartsTable,
+  ChartsTable
+};