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

package/lib/Tracer.js

@@ -1,131 +1,129 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.tracer = exports.default = exports.PluginTracer = void 0;
-function _events() {
-  const data = require("@atlaspack/events");
-  _events = function () {
-    return data;
-  };
-  return data;
-}
-function _perf_hooks() {
-  const data = require("perf_hooks");
-  _perf_hooks = function () {
-    return data;
-  };
-  return data;
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
 }
-// @ts-ignore
+_export(exports, {
+    PluginTracer: function() {
+        return PluginTracer;
+    },
+    default: function() {
+        return Tracer;
+    },
+    tracer: function() {
+        return tracer;
+    }
+});
+const _events = require("@atlaspack/events");
+const _perf_hooks = require("perf_hooks");
 let tid;
 try {
-  tid = require('worker_threads').threadId;
-} catch {
-  tid = 0;
+    tid = require('worker_threads').threadId;
+} catch  {
+    tid = 0;
 }
 const pid = process.pid;
 class TraceMeasurement {
-  #active = true;
-  #name;
-  #pid;
-  #tid;
-  #start;
-  // $FlowFixMe
-  #data;
-  constructor(tracer, name, pid, tid, data) {
-    this.#name = name;
-    this.#pid = pid;
-    this.#tid = tid;
-    this.#start = _perf_hooks().performance.now();
-    this.#data = data;
-  }
-  end() {
-    if (!this.#active) return;
-    const duration = _perf_hooks().performance.now() - this.#start;
-    tracer.trace({
-      type: 'trace',
-      name: this.#name,
-      pid: this.#pid,
-      tid: this.#tid,
-      duration,
-      ts: this.#start,
-      ...this.#data
-    });
-    this.#active = false;
-  }
+    #active = true;
+    #name;
+    #pid;
+    #tid;
+    #start;
+    // $FlowFixMe
+    #data;
+    constructor(tracer, name, pid, tid, data){
+        this.#name = name;
+        this.#pid = pid;
+        this.#tid = tid;
+        this.#start = _perf_hooks.performance.now();
+        this.#data = data;
+    }
+    end() {
+        if (!this.#active) return;
+        const duration = _perf_hooks.performance.now() - this.#start;
+        tracer.trace({
+            type: 'trace',
+            name: this.#name,
+            pid: this.#pid,
+            tid: this.#tid,
+            duration,
+            ts: this.#start,
+            ...this.#data
+        });
+        this.#active = false;
+    }
 }
 class Tracer {
-  #traceEmitter = new (_events().ValueEmitter)();
-  #enabled = false;
-  onTrace(cb) {
-    return this.#traceEmitter.addListener(cb);
-  }
-  async wrap(name, fn) {
-    let measurement = this.createMeasurement(name);
-    try {
-      await fn();
-    } finally {
-      measurement && measurement.end();
+    #traceEmitter = new _events.ValueEmitter();
+    #enabled = false;
+    onTrace(cb) {
+        return this.#traceEmitter.addListener(cb);
     }
-  }
-  createMeasurement(name, category = 'Core', argumentName, otherArgs) {
-    if (!this.enabled) return null;
-
-    // We create `args` in a fairly verbose way to avoid object
-    // allocation where not required.
-    let args;
-    if (typeof argumentName === 'string') {
-      args = {
-        name: argumentName
-      };
+    async wrap(name, fn) {
+        let measurement = this.createMeasurement(name);
+        try {
+            await fn();
+        } finally{
+            measurement && measurement.end();
+        }
     }
-    if (typeof otherArgs === 'object') {
-      if (typeof args == 'undefined') {
-        args = {};
-      }
-      for (const [k, v] of Object.entries(otherArgs)) {
-        args[k] = v;
-      }
+    createMeasurement(name, category = 'Core', argumentName, otherArgs) {
+        if (!this.enabled) return null;
+        // We create `args` in a fairly verbose way to avoid object
+        // allocation where not required.
+        let args;
+        if (typeof argumentName === 'string') {
+            args = {
+                name: argumentName
+            };
+        }
+        if (typeof otherArgs === 'object') {
+            if (typeof args == 'undefined') {
+                args = {};
+            }
+            for (const [k, v] of Object.entries(otherArgs)){
+                args[k] = v;
+            }
+        }
+        const data = {
+            categories: [
+                category
+            ],
+            args
+        };
+        return new TraceMeasurement(this, name, pid, tid, data);
+    }
+    get enabled() {
+        return this.#enabled;
+    }
+    enable() {
+        this.#enabled = true;
+    }
+    disable() {
+        this.#enabled = false;
+    }
+    trace(event) {
+        if (!this.#enabled) return;
+        this.#traceEmitter.emit(event);
     }
-    const data = {
-      categories: [category],
-      args
-    };
-    return new TraceMeasurement(this, name, pid, tid, data);
-  }
-  get enabled() {
-    return this.#enabled;
-  }
-  enable() {
-    this.#enabled = true;
-  }
-  disable() {
-    this.#enabled = false;
-  }
-  trace(event) {
-    if (!this.#enabled) return;
-    this.#traceEmitter.emit(event);
-  }
 }
-exports.default = Tracer;
-const tracer = exports.tracer = new Tracer();
+const tracer = new Tracer();
 class PluginTracer {
-  /** @private */
-
-  /** @private */
-
-  /** @private */
-  constructor(opts) {
-    this.origin = opts.origin;
-    this.category = opts.category;
-  }
-  get enabled() {
-    return tracer.enabled;
-  }
-  createMeasurement(name, category, argumentName, otherArgs) {
-    return tracer.createMeasurement(name, `${this.category}:${this.origin}${typeof category === 'string' ? `:${category}` : ''}`, argumentName, otherArgs);
-  }
+    /** @private */ origin;
+    /** @private */ category;
+    /** @private */ constructor(opts){
+        this.origin = opts.origin;
+        this.category = opts.category;
+    }
+    get enabled() {
+        return tracer.enabled;
+    }
+    createMeasurement(name, category, argumentName, otherArgs) {
+        return tracer.createMeasurement(name, `${this.category}:${this.origin}${typeof category === 'string' ? `:${category}` : ''}`, argumentName, otherArgs);
+    }
 }
-exports.PluginTracer = PluginTracer;

package/lib/Tracer.js.flow

@@ -0,0 +1,46 @@
+// @flow strict-local
+
+import type {
+  TraceEvent,
+  IDisposable,
+  PluginTracer as IPluginTracer,
+} from '@atlaspack/types';
+import type {
+  TraceMeasurement as ITraceMeasurement,
+  TraceMeasurementData,
+} from './types';
+import {ValueEmitter} from '@atlaspack/events';
+import {performance} from 'perf_hooks';
+
+declare export default class Tracer {
+  enabled: boolean;
+  onTrace(cb: (event: TraceEvent) => mixed): IDisposable;
+  wrap(name: string, fn: () => mixed): Promise<void> ;
+  createMeasurement(
+    name: string,
+    category?: string,
+    argumentName?: string,
+    otherArgs?: {[key: string]: mixed},
+  ): ITraceMeasurement | null;
+  enable(): void;
+  disable(): void;
+  trace(event: TraceEvent): void;
+}
+
+export var tracer: Tracer;
+
+type TracerOpts = {|
+  origin: string,
+  category: string,
+|};
+
+declare export class PluginTracer implements IPluginTracer {
+  enabled: boolean;
+  constructor(opts: TracerOpts): PluginTracer;
+  createMeasurement(
+    name: string,
+    category?: string,
+    argumentName?: string,
+    otherArgs?: {[key: string]: mixed},
+  ): ITraceMeasurement | null;
+}

package/lib/Tracer.mjs

@@ -0,0 +1,114 @@
+import { ValueEmitter } from '@atlaspack/events';
+import { performance } from 'perf_hooks';
+let tid;
+try {
+    tid = require('worker_threads').threadId;
+}
+catch {
+    tid = 0;
+}
+const pid = process.pid;
+class TraceMeasurement {
+    #active = true;
+    #name;
+    #pid;
+    #tid;
+    #start;
+    // $FlowFixMe
+    #data;
+    constructor(tracer, name, pid, tid, data) {
+        this.#name = name;
+        this.#pid = pid;
+        this.#tid = tid;
+        this.#start = performance.now();
+        this.#data = data;
+    }
+    end() {
+        if (!this.#active)
+            return;
+        const duration = performance.now() - this.#start;
+        tracer.trace({
+            type: 'trace',
+            name: this.#name,
+            pid: this.#pid,
+            tid: this.#tid,
+            duration,
+            ts: this.#start,
+            ...this.#data,
+        });
+        this.#active = false;
+    }
+}
+export default class Tracer {
+    #traceEmitter = new ValueEmitter();
+    #enabled = false;
+    onTrace(cb) {
+        return this.#traceEmitter.addListener(cb);
+    }
+    async wrap(name, fn) {
+        let measurement = this.createMeasurement(name);
+        try {
+            await fn();
+        }
+        finally {
+            measurement && measurement.end();
+        }
+    }
+    createMeasurement(name, category = 'Core', argumentName, otherArgs) {
+        if (!this.enabled)
+            return null;
+        // We create `args` in a fairly verbose way to avoid object
+        // allocation where not required.
+        let args;
+        if (typeof argumentName === 'string') {
+            args = {
+                name: argumentName,
+            };
+        }
+        if (typeof otherArgs === 'object') {
+            if (typeof args == 'undefined') {
+                args = {};
+            }
+            for (const [k, v] of Object.entries(otherArgs)) {
+                args[k] = v;
+            }
+        }
+        const data = {
+            categories: [category],
+            args,
+        };
+        return new TraceMeasurement(this, name, pid, tid, data);
+    }
+    get enabled() {
+        return this.#enabled;
+    }
+    enable() {
+        this.#enabled = true;
+    }
+    disable() {
+        this.#enabled = false;
+    }
+    trace(event) {
+        if (!this.#enabled)
+            return;
+        this.#traceEmitter.emit(event);
+    }
+}
+export const tracer = new Tracer();
+export class PluginTracer {
+    /** @private */
+    origin;
+    /** @private */
+    category;
+    /** @private */
+    constructor(opts) {
+        this.origin = opts.origin;
+        this.category = opts.category;
+    }
+    get enabled() {
+        return tracer.enabled;
+    }
+    createMeasurement(name, category, argumentName, otherArgs) {
+        return tracer.createMeasurement(name, `${this.category}:${this.origin}${typeof category === 'string' ? `:${category}` : ''}`, argumentName, otherArgs);
+    }
+}

package/lib/index.d.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/lib/index.js

@@ -3,31 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "PluginTracer", {
-  enumerable: true,
-  get: function () {
+function _export(target, all) {
+  for (var name in all) Object.defineProperty(target, name, {
+    enumerable: true,
+    get: all[name]
+  });
+}
+_export(exports, {
+  PluginTracer: function () {
     return _Tracer.PluginTracer;
-  }
-});
-Object.defineProperty(exports, "SamplingProfiler", {
-  enumerable: true,
-  get: function () {
+  },
+  SamplingProfiler: function () {
     return _SamplingProfiler.default;
-  }
-});
-Object.defineProperty(exports, "Trace", {
-  enumerable: true,
-  get: function () {
+  },
+  Trace: function () {
     return _Trace.default;
-  }
-});
-Object.defineProperty(exports, "tracer", {
-  enumerable: true,
-  get: function () {
+  },
+  tracer: function () {
     return _Tracer.tracer;
   }
 });
-var _SamplingProfiler = _interopRequireDefault(require("./SamplingProfiler"));
-var _Trace = _interopRequireDefault(require("./Trace"));
-var _Tracer = require("./Tracer");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const _SamplingProfiler = /*#__PURE__*/_interop_require_default(require("./SamplingProfiler.mjs"));
+const _Trace = /*#__PURE__*/_interop_require_default(require("./Trace.mjs"));
+const _Tracer = require("./Tracer.mjs");
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}

package/lib/index.mjs

@@ -0,0 +1,3 @@
+export { default as SamplingProfiler } from "./SamplingProfiler.mjs";
+export { default as Trace } from "./Trace.mjs";
+export { tracer, PluginTracer } from "./Tracer.mjs";

package/lib/types.js

@@ -1 +1,4 @@
-"use strict";
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/lib/types.mjs

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@atlaspack/profiler",
-  "version": "2.14.15-typescript-e769947a5.0",
+  "version": "2.14.15-typescript-6de04fbae.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
+  "type": "commonjs",
   "publishConfig": {
     "access": "public"
   },
@@ -11,20 +12,31 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
-  "source": "src/index.js",
+  "types": "lib/index.d.mts",
+  "exports": {
+    ".": {
+      "atlaspack::sources": "./src/index.mts",
+      "types": [
+        "./lib/index.d.mts",
+        "./src/index.mts"
+      ],
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./*": "./*"
+  },
   "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-tsc": "LINK_LIB=true node ../../../scripts/build-tsc.mjs"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.2-typescript-e769947a5.0",
-    "@atlaspack/events": "2.14.2-typescript-e769947a5.0",
-    "@atlaspack/types-internal": "2.14.15-typescript-e769947a5.0",
+    "@atlaspack/diagnostic": "2.14.2-typescript-6de04fbae.0",
+    "@atlaspack/events": "2.14.2-typescript-6de04fbae.0",
+    "@atlaspack/types-internal": "2.14.15-typescript-6de04fbae.0",
     "chrome-trace-event": "^1.0.2"
   },
-  "type": "commonjs",
-  "gitHead": "e769947a5b0c22d9477211ac1ce6614e6bf9def3"
+  "gitHead": "6de04fbaeccfba1e7832c737f6318cbd603fc74d"
 }

package/src/SamplingProfiler.mts

@@ -0,0 +1,94 @@
+import type { Session } from "inspector";
+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 | undefined;
+
+  async startProfiling(): Promise<unknown> {
+    let inspector: typeof import('inspector');
+
+    try {
+      inspector = await import('inspector');
+    } catch (err) {
+      throw new ThrowableDiagnostic({
+        diagnostic: {
+          message: `The inspector module isn't available`,
+          origin: '@atlaspack/workers',
+          hints: ['Disable build profiling']
+        }
+      });
+    }
+    if (!this.session) {
+      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;
+  }> {
+    if (!this.session) {
+      throw new Error('No session set')
+    }
+    return new Promise((resolve, reject) => {
+      this.session!.post(method, params, (err, p) => {
+        if (err == null) {
+          resolve((p as {
+            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;
+  }
+}

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

@@ -1,5 +1,4 @@
-// @flow
-import type {Profile} from './SamplingProfiler';
+import type {Profile} from './SamplingProfiler.mts';
 import type {Writable} from 'stream';
 import {Tracer} from 'chrome-trace-event';
 
@@ -38,7 +37,6 @@ export default class Trace {
         },
       },
     });
-
     this.tracer.instantEvent({
       name: 'TracingStartedInBrowser',
       id: this.getEventId(),
@@ -56,13 +54,12 @@ export default class Trace {
     if (this.eventId === 0) {
       this.init(profile.startTime);
     }
+
     const trace = this.tracer;
     const tid = this.tid;
     this.tid++;
-
     const cpuStartTime = profile.startTime;
     const cpuEndTime = profile.endTime;
-
     trace.instantEvent({
       tid,
       id: this.getEventId(),
@@ -74,7 +71,6 @@ export default class Trace {
       },
       ts: cpuStartTime,
     });
-
     trace.completeEvent({
       tid,
       name: 'EvaluateScript',
@@ -91,16 +87,16 @@ export default class Trace {
         },
       },
     });
-
     trace.instantEvent({
       tid,
       ts: 0,
       ph: 'M',
       cat: ['__metadata'],
       name: 'thread_name',
-      args: {name},
+      args: {
+        name,
+      },
     });
-
     trace.instantEvent({
       tid,
       name: 'CpuProfile',