@atlaspack/profiler 2.14.15-typescript-d6e6d169c.0 → 2.14.15-typescript-6de04fbae.0

package/src/{Tracer.js → Tracer.mts}

@@ -1,20 +1,17 @@
-// @flow strict-local
-
 import type {
   TraceEvent,
   IDisposable,
   PluginTracer as IPluginTracer,
-} from '@atlaspack/types';
+} from '@atlaspack/types-internal';
 import type {
   TraceMeasurement as ITraceMeasurement,
   TraceMeasurementData,
-} from './types';
-// @ts-ignore
+} from './types.mts';
 import {ValueEmitter} from '@atlaspack/events';
-
 import {performance} from 'perf_hooks';
 
-let tid;
+let tid: number;
+
 try {
   tid = require('worker_threads').threadId;
 } catch {
@@ -31,7 +28,14 @@ class TraceMeasurement implements ITraceMeasurement {
   #start: number;
   // $FlowFixMe
   #data: any;
-  constructor(tracer: Tracer, name, pid, tid, data) {
+
+  constructor(
+    tracer: Tracer,
+    name: string,
+    pid: number,
+    tid: number,
+    data: any,
+  ) {
     this.#name = name;
     this.#pid = pid;
     this.#tid = tid;
@@ -57,15 +61,15 @@ class TraceMeasurement implements ITraceMeasurement {
 
 export default class Tracer {
   #traceEmitter: ValueEmitter<TraceEvent> = new ValueEmitter();
-
   #enabled: boolean = false;
 
-  onTrace(cb: (event: TraceEvent) => mixed): IDisposable {
+  onTrace(cb: (event: TraceEvent) => unknown): IDisposable {
     return this.#traceEmitter.addListener(cb);
   }
 
-  async wrap(name: string, fn: () => mixed): Promise<void> {
+  async wrap(name: string, fn: () => unknown): Promise<void> {
     let measurement = this.createMeasurement(name);
+
     try {
       await fn();
     } finally {
@@ -77,20 +81,24 @@ export default class Tracer {
     name: string,
     category: string = 'Core',
     argumentName?: string,
-    otherArgs?: {[key: string]: mixed},
+    otherArgs?: Record<string, unknown>,
   ): ITraceMeasurement | null {
     if (!this.enabled) return null;
-
     // We create `args` in a fairly verbose way to avoid object
     // allocation where not required.
-    let args: {[key: string]: mixed};
+    let args: Record<string, unknown> | undefined;
+
     if (typeof argumentName === 'string') {
-      args = {name: argumentName};
+      args = {
+        name: argumentName,
+      };
     }
+
     if (typeof otherArgs === 'object') {
       if (typeof args == 'undefined') {
         args = {};
       }
+
       for (const [k, v] of Object.entries(otherArgs)) {
         args[k] = v;
       }
@@ -100,7 +108,6 @@ export default class Tracer {
       categories: [category],
       args,
     };
-
     return new TraceMeasurement(this, name, pid, tid, data);
   }
 
@@ -121,13 +128,11 @@ export default class Tracer {
     this.#traceEmitter.emit(event);
   }
 }
-
 export const tracer: Tracer = new Tracer();
-
-type TracerOpts = {|
-  origin: string,
-  category: string,
-|};
+type TracerOpts = {
+  origin: string;
+  category: string;
+};
 export class PluginTracer implements IPluginTracer {
   /** @private */
   origin: string;
@@ -149,7 +154,7 @@ export class PluginTracer implements IPluginTracer {
     name: string,
     category?: string,
     argumentName?: string,
-    otherArgs?: {[key: string]: mixed},
+    otherArgs?: Record<string, unknown>,
   ): ITraceMeasurement | null {
     return tracer.createMeasurement(
       name,

package/src/index.mts

@@ -0,0 +1,4 @@
+export { default as SamplingProfiler } from "./SamplingProfiler.mts";
+export { default as Trace } from "./Trace.mts";
+export { tracer, PluginTracer } from "./Tracer.mts";
+export type { TraceMeasurement, TraceMeasurementData } from "./types.mts";

package/src/types.mts

@@ -0,0 +1,6 @@
+export type { TraceMeasurement } from "@atlaspack/types-internal";
+
+export type TraceMeasurementData = {
+  readonly categories: string[];
+  readonly args?: Record<string, unknown>;
+};

package/test/{Tracer.test.js → Tracer.test.mts}

@@ -1,16 +1,18 @@
-// @flow
-import {tracer, PluginTracer} from '../src/Tracer';
+import type {IDisposable} from '@atlaspack/types-internal';
+import {tracer, PluginTracer} from '../src/Tracer.mts';
 import sinon from 'sinon';
 import assert from 'assert';
 
 describe('Tracer', () => {
-  let onTrace;
-  let traceDisposable;
+  let onTrace: sinon.SinonSpy;
+  let traceDisposable: IDisposable;
+
   beforeEach(() => {
     onTrace = sinon.spy();
     traceDisposable = tracer.onTrace(onTrace);
     tracer.enable();
   });
+
   afterEach(() => {
     traceDisposable.dispose();
   });
@@ -21,6 +23,7 @@ describe('Tracer', () => {
     assert(measurement == null);
     assert(onTrace.notCalled);
   });
+
   it('emits a basic trace event', () => {
     const measurement = tracer.createMeasurement('test');
     if (!measurement) return assert.fail();
@@ -35,6 +38,7 @@ describe('Tracer', () => {
       }),
     );
   });
+
   it('emits a complex trace event', () => {
     const measurement = tracer.createMeasurement('test', 'myPlugin', 'aaargh', {
       extra: 'data',
@@ -52,6 +56,7 @@ describe('Tracer', () => {
       }),
     );
   });
+
   it('calling end twice on measurment should be a no-op', () => {
     const measurement = tracer.createMeasurement('test');
     if (!measurement) return assert.fail();

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}

package/build-ts.js

@@ -1,8 +0,0 @@
-const fs = require('fs');
-
-let contents = fs.readFileSync(__dirname + '/lib/Tracer.d.ts', 'utf8');
-
-// Some fixups of typescript output
-contents = contents.replace(/^\s*#private;\s*$/gm, '');
-
-fs.writeFileSync(__dirname + '/lib/Tracer.d.ts', contents);

package/lib/index.d.ts

@@ -1,4 +0,0 @@
-export { default as SamplingProfiler } from "./SamplingProfiler";
-export { default as Trace } from "./Trace";
-export { tracer, PluginTracer } from "./Tracer";
-export type { TraceMeasurement, TraceMeasurementData } from "./types";

package/src/SamplingProfiler.js

@@ -1,93 +0,0 @@
-// @flow
-import type {Session} from 'inspector';
-import invariant from 'assert';
-import ThrowableDiagnostic from '@atlaspack/diagnostic';
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-Profile
-export type Profile = {|
-  nodes: Array<ProfileNode>,
-  startTime: number,
-  endTime: number,
-  samples?: Array<number>,
-  timeDeltas?: Array<number>,
-|};
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ProfileNode
-type ProfileNode = {|
-  id: number,
-  callFrame: CallFrame,
-  hitCount?: number,
-  children?: Array<number>,
-  deoptReason?: string,
-  positionTicks?: PositionTickInfo,
-|};
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Runtime#type-CallFrame
-type CallFrame = {|
-  functionName: string,
-  scriptId: string,
-  url: string,
-  lineNumber: string,
-  columnNumber: string,
-|};
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-PositionTickInfo
-type PositionTickInfo = {|
-  line: number,
-  ticks: number,
-|};
-
-export default class SamplingProfiler {
-  session: Session;
-
-  startProfiling(): Promise<mixed> {
-    let inspector;
-    try {
-      inspector = require('inspector');
-    } catch (err) {
-      throw new ThrowableDiagnostic({
-        diagnostic: {
-          message: `The inspector module isn't available`,
-          origin: '@atlaspack/workers',
-          hints: ['Disable build profiling'],
-        },
-      });
-    }
-
-    this.session = new inspector.Session();
-    this.session.connect();
-
-    return Promise.all([
-      this.sendCommand('Profiler.setSamplingInterval', {
-        interval: 100,
-      }),
-      this.sendCommand('Profiler.enable'),
-      this.sendCommand('Profiler.start'),
-    ]);
-  }
-
-  sendCommand(method: string, params?: any): Promise<{profile: Profile, ...}> {
-    invariant(this.session != null);
-    return new Promise((resolve, reject) => {
-      this.session.post(method, params, (err, p) => {
-        if (err == null) {
-          resolve((p: {profile: Profile, ...}));
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-
-  destroy() {
-    if (this.session != null) {
-      this.session.disconnect();
-    }
-  }
-
-  async stopProfiling(): Promise<Profile> {
-    let res = await this.sendCommand('Profiler.stop');
-    this.destroy();
-    return res.profile;
-  }
-}