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

package/lib/{SamplingProfiler.d.ts → SamplingProfiler.d.mts}

@@ -26,7 +26,7 @@ type PositionTickInfo = {
     ticks: number;
 };
 export default class SamplingProfiler {
-    session: Session;
+    session: Session | undefined;
     startProfiling(): Promise<unknown>;
     sendCommand(method: string, params?: any): Promise<{
         profile: Profile;

package/lib/SamplingProfiler.js

@@ -1,69 +1,111 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = void 0;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return SamplingProfiler;
+    }
+});
+const _diagnostic = /*#__PURE__*/ _interop_require_default(require("@atlaspack/diagnostic"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
 }
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-Profile
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ProfileNode
-// https://chromedevtools.github.io/devtools-protocol/tot/Runtime#type-CallFrame
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-PositionTickInfo
 class SamplingProfiler {
-  startProfiling() {
-    let inspector;
-    try {
-      inspector = require('inspector');
-    } catch (err) {
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: `The inspector module isn't available`,
-          origin: '@atlaspack/workers',
-          hints: ['Disable build profiling']
+    session;
+    async startProfiling() {
+        let inspector;
+        try {
+            inspector = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("inspector")));
+        } catch (err) {
+            throw new _diagnostic.default({
+                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')
+        ]);
     }
-    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, params) {
-    (0, _assert().default)(this.session != null);
-    return new Promise((resolve, reject) => {
-      this.session.post(method, params, (err, p) => {
-        if (err == null) {
-          resolve(p);
-        } else {
-          reject(err);
+    sendCommand(method, params) {
+        if (!this.session) {
+            throw new Error('No session set');
         }
-      });
-    });
-  }
-  destroy() {
-    if (this.session != null) {
-      this.session.disconnect();
+        return new Promise((resolve, reject)=>{
+            this.session.post(method, params, (err, p)=>{
+                if (err == null) {
+                    resolve(p);
+                } else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    destroy() {
+        if (this.session != null) {
+            this.session.disconnect();
+        }
+    }
+    async stopProfiling() {
+        let res = await this.sendCommand('Profiler.stop');
+        this.destroy();
+        return res.profile;
     }
-  }
-  async stopProfiling() {
-    let res = await this.sendCommand('Profiler.stop');
-    this.destroy();
-    return res.profile;
-  }
 }
-exports.default = SamplingProfiler;

package/lib/SamplingProfiler.js.flow

@@ -0,0 +1,47 @@
+// @flow
+import type {Session} from 'inspector';
+import invariant from 'assert';
+// @ts-expect-error TSMIGRATION
+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,
+|};
+
+declare export default class SamplingProfiler {
+  session: Session;
+  startProfiling(): Promise<mixed>;
+  sendCommand(method: string, params?: any): Promise<{profile: Profile, ...}>;
+  destroy(): void;
+  stopProfiling(): Promise<Profile>;
+}

package/lib/SamplingProfiler.mjs

@@ -0,0 +1,51 @@
+import ThrowableDiagnostic from "@atlaspack/diagnostic";
+export default class SamplingProfiler {
+    session;
+    async startProfiling() {
+        let 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, params) {
+        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);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    destroy() {
+        if (this.session != null) {
+            this.session.disconnect();
+        }
+    }
+    async stopProfiling() {
+        let res = await this.sendCommand('Profiler.stop');
+        this.destroy();
+        return res.profile;
+    }
+}

package/lib/{Trace.d.ts → Trace.d.mts}

@@ -1,6 +1,6 @@
-import type { Profile } from "./SamplingProfiler";
-import type { Writable } from "stream";
-import { Tracer } from "chrome-trace-event";
+import type { Profile } from './SamplingProfiler.mts';
+import type { Writable } from 'stream';
+import { Tracer } from 'chrome-trace-event';
 export default class Trace {
     tracer: Tracer;
     tid: number;

package/lib/Trace.js

@@ -1,119 +1,133 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = void 0;
-function _chromeTraceEvent() {
-  const data = require("chrome-trace-event");
-  _chromeTraceEvent = function () {
-    return data;
-  };
-  return data;
-}
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Trace;
+    }
+});
+const _chrometraceevent = require("chrome-trace-event");
 class Trace {
-  constructor() {
-    this.tracer = new (_chromeTraceEvent().Tracer)();
-    this.tid = 0;
-    this.eventId = 0;
-  }
-  getEventId() {
-    return this.eventId++;
-  }
-  init(ts) {
-    this.tracer.instantEvent({
-      name: 'TracingStartedInPage',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1',
-          page: '0xfff',
-          frames: [{
-            frame: '0xfff',
-            url: 'parcel',
-            name: ''
-          }]
-        }
-      }
-    });
-    this.tracer.instantEvent({
-      name: 'TracingStartedInBrowser',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1'
-        }
-      }
-    });
-  }
-  addCPUProfile(name, profile) {
-    if (this.eventId === 0) {
-      this.init(profile.startTime);
+    tracer;
+    tid;
+    eventId;
+    constructor(){
+        this.tracer = new _chrometraceevent.Tracer();
+        this.tid = 0;
+        this.eventId = 0;
     }
-    const trace = this.tracer;
-    const tid = this.tid;
-    this.tid++;
-    const cpuStartTime = profile.startTime;
-    const cpuEndTime = profile.endTime;
-    trace.instantEvent({
-      tid,
-      id: this.getEventId(),
-      cat: ['toplevel'],
-      name: 'TaskQueueManager::ProcessTaskFromWorkQueue',
-      args: {
-        src_file: '../../ipc/ipc_moji_bootstrap.cc',
-        src_func: 'Accept'
-      },
-      ts: cpuStartTime
-    });
-    trace.completeEvent({
-      tid,
-      name: 'EvaluateScript',
-      id: this.getEventId(),
-      cat: ['devtools.timeline'],
-      ts: cpuStartTime,
-      dur: cpuEndTime - cpuStartTime,
-      args: {
-        data: {
-          url: 'parcel',
-          lineNumber: 1,
-          columnNumber: 1,
-          frame: '0xFFF'
-        }
-      }
-    });
-    trace.instantEvent({
-      tid,
-      ts: 0,
-      ph: 'M',
-      cat: ['__metadata'],
-      name: 'thread_name',
-      args: {
-        name
-      }
-    });
-    trace.instantEvent({
-      tid,
-      name: 'CpuProfile',
-      id: this.getEventId(),
-      cat: ['disabled-by-default-devtools.timeline'],
-      ts: cpuEndTime,
-      args: {
-        data: {
-          cpuProfile: profile
+    getEventId() {
+        return this.eventId++;
+    }
+    init(ts) {
+        this.tracer.instantEvent({
+            name: 'TracingStartedInPage',
+            id: this.getEventId(),
+            ts,
+            cat: [
+                'disabled-by-default-devtools.timeline'
+            ],
+            args: {
+                data: {
+                    sessionId: '-1',
+                    page: '0xfff',
+                    frames: [
+                        {
+                            frame: '0xfff',
+                            url: 'parcel',
+                            name: ''
+                        }
+                    ]
+                }
+            }
+        });
+        this.tracer.instantEvent({
+            name: 'TracingStartedInBrowser',
+            id: this.getEventId(),
+            ts,
+            cat: [
+                'disabled-by-default-devtools.timeline'
+            ],
+            args: {
+                data: {
+                    sessionId: '-1'
+                }
+            }
+        });
+    }
+    addCPUProfile(name, profile) {
+        if (this.eventId === 0) {
+            this.init(profile.startTime);
         }
-      }
-    });
-  }
-  pipe(writable) {
-    return this.tracer.pipe(writable);
-  }
-  flush() {
-    this.tracer.push(null);
-  }
+        const trace = this.tracer;
+        const tid = this.tid;
+        this.tid++;
+        const cpuStartTime = profile.startTime;
+        const cpuEndTime = profile.endTime;
+        trace.instantEvent({
+            tid,
+            id: this.getEventId(),
+            cat: [
+                'toplevel'
+            ],
+            name: 'TaskQueueManager::ProcessTaskFromWorkQueue',
+            args: {
+                src_file: '../../ipc/ipc_moji_bootstrap.cc',
+                src_func: 'Accept'
+            },
+            ts: cpuStartTime
+        });
+        trace.completeEvent({
+            tid,
+            name: 'EvaluateScript',
+            id: this.getEventId(),
+            cat: [
+                'devtools.timeline'
+            ],
+            ts: cpuStartTime,
+            dur: cpuEndTime - cpuStartTime,
+            args: {
+                data: {
+                    url: 'parcel',
+                    lineNumber: 1,
+                    columnNumber: 1,
+                    frame: '0xFFF'
+                }
+            }
+        });
+        trace.instantEvent({
+            tid,
+            ts: 0,
+            ph: 'M',
+            cat: [
+                '__metadata'
+            ],
+            name: 'thread_name',
+            args: {
+                name
+            }
+        });
+        trace.instantEvent({
+            tid,
+            name: 'CpuProfile',
+            id: this.getEventId(),
+            cat: [
+                'disabled-by-default-devtools.timeline'
+            ],
+            ts: cpuEndTime,
+            args: {
+                data: {
+                    cpuProfile: profile
+                }
+            }
+        });
+    }
+    pipe(writable) {
+        return this.tracer.pipe(writable);
+    }
+    flush() {
+        this.tracer.push(null);
+    }
 }
-exports.default = Trace;

package/lib/Trace.js.flow

@@ -0,0 +1,15 @@
+// @flow
+import type {Profile} from './SamplingProfiler';
+import type {Writable} from 'stream';
+import {Tracer} from 'chrome-trace-event';
+
+declare export default class Trace {
+  tracer: Tracer;
+  tid: number;
+  eventId: number;
+  getEventId(): number;
+  init(ts: number): void;
+  addCPUProfile(name: string, profile: Profile): void;
+  pipe(writable: Writable): Writable;
+  flush(): void;
+}

package/lib/Trace.mjs

@@ -0,0 +1,111 @@
+import { Tracer } from 'chrome-trace-event';
+export default class Trace {
+    tracer;
+    tid;
+    eventId;
+    constructor() {
+        this.tracer = new Tracer();
+        this.tid = 0;
+        this.eventId = 0;
+    }
+    getEventId() {
+        return this.eventId++;
+    }
+    init(ts) {
+        this.tracer.instantEvent({
+            name: 'TracingStartedInPage',
+            id: this.getEventId(),
+            ts,
+            cat: ['disabled-by-default-devtools.timeline'],
+            args: {
+                data: {
+                    sessionId: '-1',
+                    page: '0xfff',
+                    frames: [
+                        {
+                            frame: '0xfff',
+                            url: 'parcel',
+                            name: '',
+                        },
+                    ],
+                },
+            },
+        });
+        this.tracer.instantEvent({
+            name: 'TracingStartedInBrowser',
+            id: this.getEventId(),
+            ts,
+            cat: ['disabled-by-default-devtools.timeline'],
+            args: {
+                data: {
+                    sessionId: '-1',
+                },
+            },
+        });
+    }
+    addCPUProfile(name, profile) {
+        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(),
+            cat: ['toplevel'],
+            name: 'TaskQueueManager::ProcessTaskFromWorkQueue',
+            args: {
+                src_file: '../../ipc/ipc_moji_bootstrap.cc',
+                src_func: 'Accept',
+            },
+            ts: cpuStartTime,
+        });
+        trace.completeEvent({
+            tid,
+            name: 'EvaluateScript',
+            id: this.getEventId(),
+            cat: ['devtools.timeline'],
+            ts: cpuStartTime,
+            dur: cpuEndTime - cpuStartTime,
+            args: {
+                data: {
+                    url: 'parcel',
+                    lineNumber: 1,
+                    columnNumber: 1,
+                    frame: '0xFFF',
+                },
+            },
+        });
+        trace.instantEvent({
+            tid,
+            ts: 0,
+            ph: 'M',
+            cat: ['__metadata'],
+            name: 'thread_name',
+            args: {
+                name,
+            },
+        });
+        trace.instantEvent({
+            tid,
+            name: 'CpuProfile',
+            id: this.getEventId(),
+            cat: ['disabled-by-default-devtools.timeline'],
+            ts: cpuEndTime,
+            args: {
+                data: {
+                    cpuProfile: profile,
+                },
+            },
+        });
+    }
+    pipe(writable) {
+        return this.tracer.pipe(writable);
+    }
+    flush() {
+        this.tracer.push(null);
+    }
+}

package/lib/{Tracer.d.ts → Tracer.d.mts}

@@ -1,7 +1,7 @@
-import type { TraceEvent, IDisposable, PluginTracer as IPluginTracer } from "@atlaspack/types";
-import type { TraceMeasurement as ITraceMeasurement } from "./types";
+import type { TraceEvent, IDisposable, PluginTracer as IPluginTracer } from '@atlaspack/types-internal';
+import type { TraceMeasurement as ITraceMeasurement } from './types.mts';
 export default class Tracer {
-
+    #private;
     onTrace(cb: (event: TraceEvent) => unknown): IDisposable;
     wrap(name: string, fn: () => unknown): Promise<void>;
     createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: Record<string, unknown>): ITraceMeasurement | null;