@atlaspack/profiler 2.14.1-canary.31 → 2.14.1-canary.311

package/CHANGELOG.md

@@ -1,5 +1,238 @@
 # @atlaspack/profiler
 
+## 2.14.31
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.20.4
+
+## 2.14.30
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.20.3
+
+## 2.14.29
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.20.2
+
+## 2.14.28
+
+### Patch Changes
+
+- [#785](https://github.com/atlassian-labs/atlaspack/pull/785) [`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922) Thanks [@matt-koko](https://github.com/matt-koko)! - We need to re-publish every package in Atlaspack with the corrected types field.
+
+- Updated dependencies [[`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922)]:
+  - @atlaspack/diagnostic@2.14.4
+  - @atlaspack/types-internal@2.20.1
+  - @atlaspack/events@2.14.4
+
+## 2.14.27
+
+### Patch Changes
+
+- Updated dependencies [[`eedcbc4`](https://github.com/atlassian-labs/atlaspack/commit/eedcbc408fc1e86a2a8e25f1a41c57146d8529e1), [`f6532d7`](https://github.com/atlassian-labs/atlaspack/commit/f6532d7a4f7f007bd4e5e36af04dd466f0b9f572)]:
+  - @atlaspack/types-internal@2.20.0
+
+## 2.14.26
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.5
+
+## 2.14.25
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.4
+
+## 2.14.24
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.3
+
+## 2.14.23
+
+### Patch Changes
+
+- [#742](https://github.com/atlassian-labs/atlaspack/pull/742) [`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd) Thanks [@yamadapc](https://github.com/yamadapc)! - Internal changes and bug fixes to environmentDeduplication flag
+
+- Updated dependencies [[`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd)]:
+  - @atlaspack/types-internal@2.19.2
+  - @atlaspack/diagnostic@2.14.3
+  - @atlaspack/events@2.14.3
+
+## 2.14.22
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.1
+
+## 2.14.21
+
+### Patch Changes
+
+- Updated dependencies [[`7f5841c`](https://github.com/atlassian-labs/atlaspack/commit/7f5841c39df049f9546cccbeea2a7337e0337b45)]:
+  - @atlaspack/types-internal@2.19.0
+
+## 2.14.20
+
+### Patch Changes
+
+- Updated dependencies [[`23d561e`](https://github.com/atlassian-labs/atlaspack/commit/23d561e51e68b0c38fd1ff4e4fb173e5e7b01cf2)]:
+  - @atlaspack/types-internal@2.18.0
+
+## 2.14.19
+
+### Patch Changes
+
+- [#720](https://github.com/atlassian-labs/atlaspack/pull/720) [`d2fd849`](https://github.com/atlassian-labs/atlaspack/commit/d2fd849770fe6305e9c694bd97b1bd905abd9d94) Thanks [@alshdavid](https://github.com/alshdavid)! - Migrate to TypeScript
+
+- Updated dependencies [[`d2fd849`](https://github.com/atlassian-labs/atlaspack/commit/d2fd849770fe6305e9c694bd97b1bd905abd9d94), [`43fdd22`](https://github.com/atlassian-labs/atlaspack/commit/43fdd223860fbc97af17d68c65419b97412cb888)]:
+  - @atlaspack/types-internal@2.17.0
+  - @atlaspack/diagnostic@2.14.2
+  - @atlaspack/events@2.14.2
+
+## 2.14.18
+
+### Patch Changes
+
+- Updated dependencies [[`069de47`](https://github.com/atlassian-labs/atlaspack/commit/069de478e64fb5889f6f2ce023eb510782767fbd)]:
+  - @atlaspack/types-internal@2.16.0
+
+## 2.14.17
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.15.2
+
+## 2.14.16
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.15.1
+
+## 2.14.15
+
+### Patch Changes
+
+- Updated dependencies [[`18a57cf`](https://github.com/atlassian-labs/atlaspack/commit/18a57cf8a4789b2de5ad8e2676f317a26cc91417)]:
+  - @atlaspack/types-internal@2.15.0
+
+## 2.14.14
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.14
+
+## 2.14.13
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.13
+
+## 2.14.12
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.12
+
+## 2.14.11
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.11
+
+## 2.14.10
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.10
+
+## 2.14.9
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.9
+
+## 2.14.8
+
+### Patch Changes
+
+- Updated dependencies [[`51aba5f`](https://github.com/atlassian-labs/atlaspack/commit/51aba5fc0e49235ee06bbc3c376f48c3e7da5c4b)]:
+  - @atlaspack/types-internal@2.14.8
+
+## 2.14.7
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.7
+
+## 2.14.6
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.6
+
+## 2.14.5
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.5
+
+## 2.14.4
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.4
+
+## 2.14.3
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.3
+
+## 2.14.2
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.14.2
+
+## 2.14.1
+
+### Patch Changes
+
+- [#478](https://github.com/atlassian-labs/atlaspack/pull/478) [`570493b`](https://github.com/atlassian-labs/atlaspack/commit/570493beaf754e7985aebc7daaaf6dfcfa8fe56b) Thanks [@yamadapc](https://github.com/yamadapc)! - The first attempt at Version Packages didn't include the built artifacts.
+  This has hopefully been fixed, so this change will force those packages to re-release.
+- Updated dependencies [[`e1422ad`](https://github.com/atlassian-labs/atlaspack/commit/e1422ad0a801faaa4bc4f1023bed042ffe236e9b), [`570493b`](https://github.com/atlassian-labs/atlaspack/commit/570493beaf754e7985aebc7daaaf6dfcfa8fe56b)]:
+  - @atlaspack/types-internal@2.14.1
+  - @atlaspack/diagnostic@2.14.1
+  - @atlaspack/events@2.14.1
+
 ## 2.14.0
 
 ### Minor Changes

package/dist/SamplingProfiler.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+class SamplingProfiler {
+    startProfiling() {
+        let inspector;
+        try {
+            inspector = require('inspector');
+        }
+        catch (err) {
+            throw new diagnostic_1.default({
+                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, params) {
+        (0, assert_1.default)(this.session != null);
+        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;
+    }
+}
+exports.default = SamplingProfiler;

package/dist/Trace.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chrome_trace_event_1 = require("chrome-trace-event");
+class Trace {
+    constructor() {
+        this.tracer = new chrome_trace_event_1.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);
+    }
+}
+exports.default = Trace;

package/dist/Tracer.js

@@ -0,0 +1,132 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TraceMeasurement_active, _TraceMeasurement_name, _TraceMeasurement_pid, _TraceMeasurement_tid, _TraceMeasurement_start, _TraceMeasurement_data, _Tracer_traceEmitter, _Tracer_enabled;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTracer = exports.tracer = void 0;
+const events_1 = require("@atlaspack/events");
+const perf_hooks_1 = require("perf_hooks");
+// @ts-expect-error TS7034
+let tid;
+try {
+    tid = require('worker_threads').threadId;
+}
+catch {
+    tid = 0;
+}
+const pid = process.pid;
+class TraceMeasurement {
+    constructor(tracer, name, pid, tid, data) {
+        _TraceMeasurement_active.set(this, true);
+        _TraceMeasurement_name.set(this, void 0);
+        _TraceMeasurement_pid.set(this, void 0);
+        _TraceMeasurement_tid.set(this, void 0);
+        _TraceMeasurement_start.set(this, void 0);
+        _TraceMeasurement_data.set(this, void 0);
+        __classPrivateFieldSet(this, _TraceMeasurement_name, name, "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_pid, pid, "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_tid, tid, "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_start, perf_hooks_1.performance.now(), "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_data, data, "f");
+    }
+    end() {
+        if (!__classPrivateFieldGet(this, _TraceMeasurement_active, "f"))
+            return;
+        const duration = perf_hooks_1.performance.now() - __classPrivateFieldGet(this, _TraceMeasurement_start, "f");
+        exports.tracer.trace({
+            type: 'trace',
+            name: __classPrivateFieldGet(this, _TraceMeasurement_name, "f"),
+            pid: __classPrivateFieldGet(this, _TraceMeasurement_pid, "f"),
+            tid: __classPrivateFieldGet(this, _TraceMeasurement_tid, "f"),
+            duration,
+            ts: __classPrivateFieldGet(this, _TraceMeasurement_start, "f"),
+            ...__classPrivateFieldGet(this, _TraceMeasurement_data, "f"),
+        });
+        __classPrivateFieldSet(this, _TraceMeasurement_active, false, "f");
+    }
+}
+_TraceMeasurement_active = new WeakMap(), _TraceMeasurement_name = new WeakMap(), _TraceMeasurement_pid = new WeakMap(), _TraceMeasurement_tid = new WeakMap(), _TraceMeasurement_start = new WeakMap(), _TraceMeasurement_data = new WeakMap();
+class Tracer {
+    constructor() {
+        _Tracer_traceEmitter.set(this, new events_1.ValueEmitter());
+        _Tracer_enabled.set(this, false);
+    }
+    onTrace(cb) {
+        return __classPrivateFieldGet(this, _Tracer_traceEmitter, "f").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') {
+            // @ts-expect-error TS2454
+            if (typeof args == 'undefined') {
+                args = {};
+            }
+            for (const [k, v] of Object.entries(otherArgs)) {
+                args[k] = v;
+            }
+        }
+        const data = {
+            categories: [category],
+            // @ts-expect-error TS2454
+            args,
+        };
+        // @ts-expect-error TS7005
+        return new TraceMeasurement(this, name, pid, tid, data);
+    }
+    get enabled() {
+        return __classPrivateFieldGet(this, _Tracer_enabled, "f");
+    }
+    enable() {
+        __classPrivateFieldSet(this, _Tracer_enabled, true, "f");
+    }
+    disable() {
+        __classPrivateFieldSet(this, _Tracer_enabled, false, "f");
+    }
+    trace(event) {
+        if (!__classPrivateFieldGet(this, _Tracer_enabled, "f"))
+            return;
+        __classPrivateFieldGet(this, _Tracer_traceEmitter, "f").emit(event);
+    }
+}
+_Tracer_traceEmitter = new WeakMap(), _Tracer_enabled = new WeakMap();
+exports.default = Tracer;
+exports.tracer = new Tracer();
+class PluginTracer {
+    /** @private */
+    constructor(opts) {
+        this.origin = opts.origin;
+        this.category = opts.category;
+    }
+    get enabled() {
+        return exports.tracer.enabled;
+    }
+    createMeasurement(name, category, argumentName, otherArgs) {
+        return exports.tracer.createMeasurement(name, `${this.category}:${this.origin}${typeof category === 'string' ? `:${category}` : ''}`, argumentName, otherArgs);
+    }
+}
+exports.PluginTracer = PluginTracer;

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTracer = exports.tracer = exports.Trace = exports.SamplingProfiler = void 0;
+var SamplingProfiler_1 = require("./SamplingProfiler");
+Object.defineProperty(exports, "SamplingProfiler", { enumerable: true, get: function () { return __importDefault(SamplingProfiler_1).default; } });
+var Trace_1 = require("./Trace");
+Object.defineProperty(exports, "Trace", { enumerable: true, get: function () { return __importDefault(Trace_1).default; } });
+var Tracer_1 = require("./Tracer");
+Object.defineProperty(exports, "tracer", { enumerable: true, get: function () { return Tracer_1.tracer; } });
+Object.defineProperty(exports, "PluginTracer", { enumerable: true, get: function () { return Tracer_1.PluginTracer; } });

package/dist/types.js

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

package/lib/SamplingProfiler.js

@@ -20,10 +20,16 @@ function _diagnostic() {
 }
 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 {
+  // @ts-expect-error not initialized
+
   startProfiling() {
     let inspector;
     try {

package/lib/Tracer.js

@@ -18,7 +18,7 @@ function _perf_hooks() {
   };
   return data;
 }
-// @ts-ignore
+// @ts-expect-error TS7034
 let tid;
 try {
   tid = require('worker_threads').threadId;
@@ -32,7 +32,6 @@ class TraceMeasurement {
   #pid;
   #tid;
   #start;
-  // $FlowFixMe
   #data;
   constructor(tracer, name, pid, tid, data) {
     this.#name = name;
@@ -82,6 +81,7 @@ class Tracer {
       };
     }
     if (typeof otherArgs === 'object') {
+      // @ts-expect-error TS2454
       if (typeof args == 'undefined') {
         args = {};
       }
@@ -91,8 +91,11 @@ class Tracer {
     }
     const data = {
       categories: [category],
+      // @ts-expect-error TS2454
       args
     };
+
+    // @ts-expect-error TS7005
     return new TraceMeasurement(this, name, pid, tid, data);
   }
   get enabled() {

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

@@ -1,4 +1,4 @@
-import type { Session } from "inspector";
+import type { Session } from 'inspector';
 export type Profile = {
     nodes: Array<ProfileNode>;
     startTime: number;
@@ -28,7 +28,7 @@ type PositionTickInfo = {
 export default class SamplingProfiler {
     session: Session;
     startProfiling(): Promise<unknown>;
-    sendCommand(method: string, params?: unknown): Promise<{
+    sendCommand(method: string, params?: any): Promise<{
         profile: Profile;
     }>;
     destroy(): void;

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

@@ -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';
+import type { Writable } from 'stream';
+import { Tracer } from 'chrome-trace-event';
 export default class Trace {
     tracer: Tracer;
     tid: number;

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

@@ -1,10 +1,12 @@
-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';
 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;
+    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: {
+        [key: string]: unknown;
+    }): ITraceMeasurement | null;
     get enabled(): boolean;
     enable(): void;
     disable(): void;
@@ -23,6 +25,8 @@ export declare class PluginTracer implements IPluginTracer {
     /** @private */
     constructor(opts: TracerOpts);
     get enabled(): boolean;
-    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: Record<string, unknown>): ITraceMeasurement | null;
+    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: {
+        [key: string]: unknown;
+    }): ITraceMeasurement | null;
 }
 export {};

package/lib/types/index.d.ts

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

package/lib/types/types.d.ts

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