fix(types): fix exported types

index.d.ts

@@ -1,14 +1,26 @@
 import { Sampler, SamplerOptions } from './types/sampler'
-import errors = require('./types/errors')
+import errors from './types/errors'
+import { CPUMetric } from './types/cpuMetric'
+import { EventLoopDelayMetric } from './types/eventLoopDelayMetric'
+import { ResourceUsageMetric } from './types/resourceUsageMetric'
+import { EventLoopUtilizationMetric } from './types/eventLoopUtilizationMetric'
+import { GCEntry, GCAggregatedEntry, GCMetric } from './types/gcMetric'
 
-declare function createSampler(options?: SamplerOptions): Sampler
-export default createSampler
+declare module 'doc' {
 
-export { createSampler }
-export { Sampler, SamplerOptions }
-export { errors }
-export * from './types/cpuMetric'
-export * from './types/eventLoopDelayMetric'
-export * from './types/resourceUsageMetric'
-export * from './types/eventLoopUtilizationMetric'
-export * from './types/gcMetric'
+}
+declare namespace doc {
+  export { errors }
+  export type {
+    Sampler, SamplerOptions,
+    CPUMetric,
+    EventLoopDelayMetric,
+    ResourceUsageMetric,
+    EventLoopUtilizationMetric,
+    GCEntry, GCAggregatedEntry, GCMetric
+  }
+  export const createSampler: (options?: SamplerOptions) => Sampler
+  export { createSampler as default }
+}
+declare function doc(options?: doc.SamplerOptions): doc.Sampler
+export = doc

index.test-d.ts

@@ -1,15 +1,14 @@
 import { expectType, expectError, expectAssignable } from 'tsd'
-import {
-  createSampler,
-  Sampler,
+import doc, { 
   errors,
+  Sampler,
   CPUMetric,
   ResourceUsageMetric,
   EventLoopDelayMetric,
   EventLoopUtilizationMetric,
   GCMetric
-} from '.'
-
+ } from '.'
+ 
 expectAssignable<errors.NotSupportedError>(new errors.NotSupportedError())
 expectAssignable<'NotSupportedError'>(new errors.NotSupportedError().name)
 expectAssignable<'DOC_ERR_NOT_SUPPORTED'>(new errors.NotSupportedError().code)
@@ -20,13 +19,13 @@ expectAssignable<'DOC_ERR_INVALID_ARG'>(new errors.InvalidArgumentError().code)
 let sampler: Sampler
 
 // These should work
-sampler = createSampler()
-sampler = createSampler({})
-sampler = createSampler({ sampleInterval: 1234 })
-sampler = createSampler({ eventLoopDelayOptions: { resolution: 5678 } })
-sampler = createSampler({ collect: { cpu: false, gc: true } })
-sampler = createSampler({ collect: { activeHandles: true } })
-sampler = createSampler({ collect: { gc: true, activeHandles: true } })
+sampler = doc()
+sampler = doc({})
+sampler = doc({ sampleInterval: 1234 })
+sampler = doc({ eventLoopDelayOptions: { resolution: 5678 } })
+sampler = doc({ collect: { cpu: false, gc: true } })
+sampler = doc({ collect: { activeHandles: true } })
+sampler = doc({ collect: { gc: true, activeHandles: true } })
 
 expectType<() => void>(sampler.start)
 expectType<() => void>(sampler.stop)
@@ -42,9 +41,9 @@ sampler.on('sample', () => {
 })
 
 // These should not
-expectError(() => { createSampler(1) })
-expectError(() => { createSampler('string') })
-expectError(() => { createSampler(null) })
-expectError(() => { createSampler({ foo: 'bar' }) })
-expectError(() => { createSampler({ sampleInterval: 'bar' }) })
-expectError(() => { createSampler({ eventLoopDelayOptions: 'bar' }) })
+expectError(() => { doc(1) })
+expectError(() => { doc('string') })
+expectError(() => { doc(null) })
+expectError(() => { doc({ foo: 'bar' }) })
+expectError(() => { doc({ sampleInterval: 'bar' }) })
+expectError(() => { doc({ eventLoopDelayOptions: 'bar' }) })

lib/eventLoopUtilization.js

@@ -10,9 +10,6 @@ const kLastSample = Symbol('kLastSample')
 
 class EventLoopUtiizationMetric {
   constructor () {
-    if (!eventLoopUtilization) {
-      throw new Error('eventLoopUtilization is not supported on this Node.js version')
-    }
     this[kLastSample] = eventLoopUtilization()
     this[kRawMetric] = this[kLastSample]
   }

test/doc.test.js

@@ -143,7 +143,7 @@ test('eventLoopDelay', t => {
   })
 })
 
-test('eventLoopUtilization', { skip: !doc.eventLoopUtilizationSupported }, t => {
+test('eventLoopUtilization', t => {
   t.plan(7)
   const sampler = doc()
 
@@ -160,7 +160,7 @@ test('eventLoopUtilization', { skip: !doc.eventLoopUtilizationSupported }, t =>
   })
 })
 
-test('gc', { only: true }, t => {
+test('gc', t => {
   t.plan(25)
   const sampler = doc({
     gcOptions: {

types/eventLoopDelayMetric.d.ts

@@ -1,19 +1,9 @@
-/**
- * On Node 12 and above this is a Histogram instance from 'perf_hooks'.
- */
-declare interface EventLoopDelayHistogram {
-  min: number,
-  max: number,
-  mean: number,
-  stddev: number,
-  percentiles: Map<number, number>,
-  exceeds: number,
-}
+import { IntervalHistogram } from "perf_hooks";
 
 export interface EventLoopDelayMetric {
   /**
     * computed delay in milliseconds
     */
   computed: number,
-  raw: number | EventLoopDelayHistogram
+  raw: IntervalHistogram
 }

types/eventLoopUtilizationMetric.d.ts

@@ -1,10 +1,8 @@
+import { EventLoopUtilization } from "perf_hooks"
+
 export interface EventLoopUtilizationMetric {
   /**
     * Raw metric value
     */
-   raw: {
-      idle: number,
-      active: number,
-      utilization: number
-   }
+   raw: EventLoopUtilization
 }

types/resourceUsageMetric.d.ts

@@ -1,3 +1,7 @@
+import { resourceUsage } from "process";
+
+type ResourceUsage = ReturnType<typeof resourceUsage>
+
 export interface ResourceUsageMetric {
   /**
     * Cpu usage percentage
@@ -6,22 +10,5 @@ export interface ResourceUsageMetric {
    /**
      * Raw vaule returned by `process.resourceUsage()`
      */
-   raw: {
-     fsRead: number;
-     fsWrite: number;
-     involuntaryContextSwitches: number;
-     ipcReceived: number;
-     ipcSent: number;
-     majorPageFault: number;
-     maxRSS: number;
-     minorPageFault: number;
-     sharedMemorySize: number;
-     signalsCount: number;
-     swappedOut: number;
-     systemCPUTime: number;
-     unsharedDataSize: number;
-     unsharedStackSize: number;
-     userCPUTime: number;
-     voluntaryContextSwitches: number;
-   }
+   raw: ResourceUsage
 }