@atlaspack/profiler 2.14.1-canary.35 → 2.14.1-canary.351

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/profiler",
-  "version": "2.14.1-canary.35+a891d652b",
+  "version": "2.14.1-canary.351+8eb84ee61",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,21 +10,21 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
-    "build-ts": "flow-to-ts src/*.js --write && rm -f ./src/*.d.ts && tsc --emitDeclarationOnly --declaration --esModuleInterop --target es2015 --moduleResolution node16 --module node16 src/*.ts && mkdir -p lib && mv src/*.d.ts lib/. && rm src/*.ts && node build-ts.js",
-    "check-ts": "tsc --noEmit lib/index.d.ts"
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.35+a891d652b",
-    "@atlaspack/events": "2.14.1-canary.35+a891d652b",
-    "@atlaspack/types-internal": "2.14.1-canary.35+a891d652b",
+    "@atlaspack/diagnostic": "2.14.1-canary.351+8eb84ee61",
+    "@atlaspack/events": "2.14.1-canary.351+8eb84ee61",
+    "@atlaspack/types-internal": "2.14.1-canary.351+8eb84ee61",
     "chrome-trace-event": "^1.0.2"
   },
   "type": "commonjs",
-  "gitHead": "a891d652bc4eb3d757d381adf65c5083f706effc"
-}
+  "gitHead": "8eb84ee61a42bfe87c58079b610802b07a6a13e4"
+}

package/src/{SamplingProfiler.js → SamplingProfiler.ts}

@@ -1,50 +1,50 @@
-// @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>,
-|};
+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,
-|};
+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,
-|};
+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,
-|};
+type PositionTickInfo = {
+  line: number;
+  ticks: number;
+};
 
 export default class SamplingProfiler {
+  // @ts-expect-error not initialized
   session: Session;
 
-  startProfiling(): Promise<mixed> {
+  startProfiling(): Promise<unknown> {
     let inspector;
     try {
       inspector = require('inspector');
-    } catch (err) {
+    } catch (err: any) {
       throw new ThrowableDiagnostic({
         diagnostic: {
           message: `The inspector module isn't available`,
@@ -68,18 +68,37 @@ export default class SamplingProfiler {
 
   sendCommand(
     method: string,
-    params?: mixed,
-  ): Promise<{profile: Profile, ...}> {
+    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);
-        }
-      });
-    });
+    return new Promise(
+      (
+        resolve: (
+          result:
+            | Promise<{
+                profile: Profile;
+              }>
+            | {
+                profile: Profile;
+              },
+        ) => void,
+        reject: (error?: any) => void,
+      ) => {
+        this.session.post(method, params, (err, p) => {
+          if (err == null) {
+            resolve(
+              p as {
+                profile: Profile;
+              },
+            );
+          } else {
+            reject(err);
+          }
+        });
+      },
+    );
   }
 
   destroy() {

package/src/{Trace.js → Trace.ts}

@@ -1,4 +1,3 @@
-// @flow
 import type {Profile} from './SamplingProfiler';
 import type {Writable} from 'stream';
 import {Tracer} from 'chrome-trace-event';

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

@@ -1,19 +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
 import {ValueEmitter} from '@atlaspack/events';
 
 import {performance} from 'perf_hooks';
 
+// @ts-expect-error TS7034
 let tid;
 try {
   tid = require('worker_threads').threadId;
@@ -29,9 +27,14 @@ class TraceMeasurement implements ITraceMeasurement {
   #pid: number;
   #tid: number;
   #start: number;
-  // $FlowFixMe
   #data: any;
-  constructor(tracer: Tracer, name, pid, tid, data) {
+  constructor(
+    tracer: Tracer,
+    name: string,
+    pid: number,
+    tid: number,
+    data: TraceMeasurementData,
+  ) {
     this.#name = name;
     this.#pid = pid;
     this.#tid = tid;
@@ -60,11 +63,11 @@ export default class Tracer {
 
   #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();
@@ -77,17 +80,22 @@ export default class Tracer {
     name: string,
     category: string = 'Core',
     argumentName?: string,
-    otherArgs?: {[key: string]: mixed},
+    otherArgs?: {
+      [key: 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: {
+      [key: string]: unknown;
+    };
     if (typeof argumentName === 'string') {
       args = {name: argumentName};
     }
     if (typeof otherArgs === 'object') {
+      // @ts-expect-error TS2454
       if (typeof args == 'undefined') {
         args = {};
       }
@@ -98,9 +106,11 @@ export default class Tracer {
 
     const data: TraceMeasurementData = {
       categories: [category],
+      // @ts-expect-error TS2454
       args,
     };
 
+    // @ts-expect-error TS7005
     return new TraceMeasurement(this, name, pid, tid, data);
   }
 
@@ -124,10 +134,10 @@ export default class Tracer {
 
 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 +159,9 @@ export class PluginTracer implements IPluginTracer {
     name: string,
     category?: string,
     argumentName?: string,
-    otherArgs?: {[key: string]: mixed},
+    otherArgs?: {
+      [key: string]: unknown;
+    },
   ): ITraceMeasurement | null {
     return tracer.createMeasurement(
       name,

package/src/{index.js → index.ts}

@@ -1,4 +1,3 @@
-// @flow
 export {default as SamplingProfiler} from './SamplingProfiler';
 export {default as Trace} from './Trace';
 export {tracer, PluginTracer} from './Tracer';

package/src/types.ts

@@ -0,0 +1,8 @@
+export type {TraceMeasurement} from '@atlaspack/types-internal';
+
+export type TraceMeasurementData = {
+  readonly categories: string[];
+  readonly args?: {
+    [key: string]: unknown;
+  };
+};

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

@@ -1,11 +1,10 @@
-// @flow
 import {tracer, PluginTracer} from '../src/Tracer';
 import sinon from 'sinon';
 import assert from 'assert';
 
 describe('Tracer', () => {
-  let onTrace;
-  let traceDisposable;
+  let onTrace: any;
+  let traceDisposable: any;
   beforeEach(() => {
     onTrace = sinon.spy();
     traceDisposable = tracer.onTrace(onTrace);

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../utils/events/tsconfig.json"
+    },
+    {
+      "path": "../diagnostic/tsconfig.json"
+    },
+    {
+      "path": "../types-internal/tsconfig.json"
+    }
+  ]
+}