DecimationAlgorithm enum not found

[Nico-DF]

Expected Behavior

I am no pro at Angular/JS, but by seeing the d.ts file and how the decimationOptions are defined, I expect the DecimationAlgorithm enum to be exported

export declare enum DecimationAlgorithm {
  lttb = 'lttb',
  minmax = 'min-max',
}

And that, when declaring options, I can use the following:

plugins: {
  decimation: {
    enabled: true,
    algorithm: DecimationAlgorithm.lttb
  }
}

Current Behavior

https://codepen.io/Nico-DF/pen/WNRWJQr

"export 'DecimationAlgorithm' was not found in 'chart.js'
error Command failed with exit code 1.

Maybe it is a misunderstanding on my side, but currently, I'm forced to do the following:

plugins: {
  decimation: {
    enabled: true,
    // @ts-ignore
    algorithm: 'lttb'
  }
}

The ts-ignore is needed due to the definition of the option

[etimberg]

The DecimationAlgorithm type is exported. https://github.com/chartjs/Chart.js/blob/master/types/index.esm.d.ts#L1955-L1958

Do you have a reproduce that uses TS? I created this test case and it worked as expected

import { Chart, DecimationAlgorithm } from '../../../index.esm';

const chart = new Chart('id', {
  type: 'bubble',
  data: {
    labels: [],
    datasets: [{
      data: []
    }]
  },
  options: {
    plugins: {
      decimation: {
        algorithm: DecimationAlgorithm.lttb,
      }
    }
  }
});

[Nico-DF]

Sorry for the delay, took a few days off, the codepen exhibits the not found exception, and for the TS, something like this does not work (which I agree is weird as I also saw the export on d.ts file)

import { ChartData, ChartDataset, ChartOptions, DecimationAlgorithm } from 'chart.js';

public static buildChartOptions(
    xLabel: string,
    yLabel: string,
    minX: number,
    maxX: number,
    zoomCallback: () => void
  ): ChartOptions {
    return {
      // We are using objects like {x: 10, y: 20}, disabling parsing for performance
      parsing: false,
      // Data are already ordered
      normalized: true,
      animation: false,
      responsive: false,
      scales: {
        y: {
          title: {
            display: true,
            text: yLabel
          },
          type: 'linear',
          ticks: {
            minRotation: 50,
            maxRotation: 50
          }
        },
        x: {
          title: {
            display: true,
            text: xLabel
          },
          type: 'linear',
          min: minX,
          max: maxX,
          ticks: {
            minRotation: 50,
            maxRotation: 50
          }
        }
      },
      plugins: {
        decimation: {
          enabled: true,
          algorithm: DecimationAlgorithm.lttb
        },
        legend: {
          align: 'start'
        },
        zoom: {
          limits: {
            x: { min: minX, max: maxX }
          },
          pan: {
            enabled: true,
            mode: 'x'
          },
          zoom: {
            enabled: true,
            mode: 'x',
            onZoom: zoomCallback
          }
        },
        tooltip: {
          mode: 'index',
          intersect: false
        }
      }
    };
  }

This functions creates for me the ChartOptions and I use it to build several different graphs.
Using the enum will fail with "export 'DecimationAlgorithm' was not found in 'chart.js'
(On IDE chart.js refers correctly to index.esm.d.ts)

[Nico-DF]

I could try to setup a mock project and post the link here if you want (probably not before tomorrow though)

[kurkle]

Here's a repro: https://codesandbox.io/s/competent-hooks-bi2i7?file=/src/index.ts

The issues is, chart.js is written in javascript, so the exported typescript enum never gets compiled and transpiled to an object, as it would in a typescript project. So it really is undefined.

The type checking works fine though, so you can just use 'lttb'.

I think we should stop exporting the enums, because those are not really usable.

Edit:
The enums are usable for augmentation

I think we should do the same as with UpdateMode:

export declare enum UpdateModeEnum {
  resize = 'resize',
  reset = 'reset',
  none = 'none',
  hide = 'hide',
  show = 'show',
  normal = 'normal',
  active = 'active'
}

export type UpdateMode = keyof typeof UpdateModeEnum;

const blah = UpdateModeEnum.hide; still does not work (for the same reason, the enum is never compiled to the lib), but const blah: UpdateMode = 'active' does, as its just type checking.

[kurkle]

And another note, seems like there is a better solution, by using const enum: https://stackoverflow.com/a/50568865/10359775

[Nico-DF]

Thanks for the update @kurkle, I agree that using 'lttb' works (it is what I'm doing right not), but if using a strict check with tslint, it will fails as string != DecimationAlgorithm, that was basically my point

[kurkle]

Sorry for missing the actual point, but I think the const enum could be an answer to that too. Unless you then really need to use something called module isolation and that is not really possible in all cases? (still really new to TS)