@recordreplay/protocol - npm Package Compare versions

Comparing version 0.2.2 to 0.3.0

js/client/build/client.d.ts

@@ -13,3 +13,3 @@ import { metadataChange, uploadedData, sessionError, getDescriptionParameters, getMetadataParameters, setMetadataParameters, metadataStartListeningParameters, metadataStopListeningParameters, createSessionParameters, releaseSessionParameters, processRecordingParameters } from "../../protocol/Recording";
 import { createRecordingParameters, setRecordingMetadataParameters, addRecordingDataParameters, addRecordingDescriptionParameters, hasResourceParameters, addResourceParameters, addRecordingResourceParameters, echoParameters, labelTestSessionParameters, getRecordingsParameters, reportCrashParameters } from "../../protocol/Internal";
-import { GenericProtocolClient } from "./generic";
+import { GenericProtocolClient } from "../generic";
 export declare class ProtocolClient {
@@ -26,3 +26,3 @@ private readonly genericClient;
         addMetadataChangeListener: (listener: (parameters: metadataChange) => void) => void;
-        removeMetadataChangeListener: () => void;
+        removeMetadataChangeListener: () => void | undefined;
         /**
@@ -32,3 +32,3 @@ * Describes how much of a recording's data has been uploaded to the cloud service.
         addUploadedDataListener: (listener: (parameters: uploadedData) => void) => void;
-        removeUploadedDataListener: () => void;
+        removeUploadedDataListener: () => void | undefined;
         /**
@@ -38,3 +38,3 @@ * Emitted when a session has died due to a server side problem.
         addSessionErrorListener: (listener: (parameters: sessionError) => void) => void;
-        removeSessionErrorListener: () => void;
+        removeSessionErrorListener: () => void | undefined;
         /**
@@ -108,3 +108,3 @@ * Get a description of a recording.
         addMissingRegionsListener: (listener: (parameters: missingRegions) => void) => void;
-        removeMissingRegionsListener: () => void;
+        removeMissingRegionsListener: () => void | undefined;
         /**
@@ -114,3 +114,3 @@ * Event describing regions of the recording that have not been processed.
         addUnprocessedRegionsListener: (listener: (parameters: unprocessedRegions) => void) => void;
-        removeUnprocessedRegionsListener: () => void;
+        removeUnprocessedRegionsListener: () => void | undefined;
         /**
@@ -120,3 +120,3 @@ * Describes some mouse events that occur in the recording.
         addMouseEventsListener: (listener: (parameters: mouseEvents) => void) => void;
-        removeMouseEventsListener: () => void;
+        removeMouseEventsListener: () => void | undefined;
         /**
@@ -161,3 +161,3 @@ * Does not return until the recording is fully processed. Before returning,
         addPaintPointsListener: (listener: (parameters: paintPoints) => void) => void;
-        removePaintPointsListener: () => void;
+        removePaintPointsListener: () => void | undefined;
         /**
@@ -192,3 +192,3 @@ * Find all points in the recording at which paints occurred. Does not return
         addNewSourceListener: (listener: (parameters: newSource) => void) => void;
-        removeNewSourceListener: () => void;
+        removeNewSourceListener: () => void | undefined;
         /**
@@ -267,3 +267,3 @@ * Find all sources in the recording. Does not return until the recording is
         addNewMessageListener: (listener: (parameters: newMessage) => void) => void;
-        removeNewMessageListener: () => void;
+        removeNewMessageListener: () => void | undefined;
         /**
@@ -413,3 +413,3 @@ * Find all messages in the recording. Does not return until the recording is
         addAnalysisResultListener: (listener: (parameters: analysisResult) => void) => void;
-        removeAnalysisResultListener: () => void;
+        removeAnalysisResultListener: () => void | undefined;
         /**
@@ -421,3 +421,3 @@ * Describes an error that occurred when running an analysis mapper or reducer
         addAnalysisErrorListener: (listener: (parameters: analysisError) => void) => void;
-        removeAnalysisErrorListener: () => void;
+        removeAnalysisErrorListener: () => void | undefined;
         /**
@@ -427,3 +427,3 @@ * Describes some points at which an analysis will run.
         addAnalysisPointsListener: (listener: (parameters: analysisPoints) => void) => void;
-        removeAnalysisPointsListener: () => void;
+        removeAnalysisPointsListener: () => void | undefined;
         /**
@@ -430,0 +430,0 @@ * Start specifying a new analysis.

js/client/build/client.js

@@ -18,5 +18,3 @@ "use strict";
             },
-            removeMetadataChangeListener: function () {
-                return _this.genericClient.removeEventListener("Recording.metadataChange");
-            },
+            removeMetadataChangeListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Recording.metadataChange"); },
             /**
@@ -28,5 +26,3 @@ * Describes how much of a recording's data has been uploaded to the cloud service.
             },
-            removeUploadedDataListener: function () {
-                return _this.genericClient.removeEventListener("Recording.uploadedData");
-            },
+            removeUploadedDataListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Recording.uploadedData"); },
             /**
@@ -38,5 +34,3 @@ * Emitted when a session has died due to a server side problem.
             },
-            removeSessionErrorListener: function () {
-                return _this.genericClient.removeEventListener("Recording.sessionError");
-            },
+            removeSessionErrorListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Recording.sessionError"); },
             /**
@@ -130,5 +124,3 @@ * Get a description of a recording.
             },
-            removeMissingRegionsListener: function () {
-                return _this.genericClient.removeEventListener("Session.missingRegions");
-            },
+            removeMissingRegionsListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Session.missingRegions"); },
             /**
@@ -140,5 +132,3 @@ * Event describing regions of the recording that have not been processed.
             },
-            removeUnprocessedRegionsListener: function () {
-                return _this.genericClient.removeEventListener("Session.unprocessedRegions");
-            },
+            removeUnprocessedRegionsListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Session.unprocessedRegions"); },
             /**
@@ -150,5 +140,3 @@ * Describes some mouse events that occur in the recording.
             },
-            removeMouseEventsListener: function () {
-                return _this.genericClient.removeEventListener("Session.mouseEvents");
-            },
+            removeMouseEventsListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Session.mouseEvents"); },
             /**
@@ -205,5 +193,3 @@ * Does not return until the recording is fully processed. Before returning,
             },
-            removePaintPointsListener: function () {
-                return _this.genericClient.removeEventListener("Graphics.paintPoints");
-            },
+            removePaintPointsListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Graphics.paintPoints"); },
             /**
@@ -246,5 +232,3 @@ * Find all points in the recording at which paints occurred. Does not return
             },
-            removeNewSourceListener: function () {
-                return _this.genericClient.removeEventListener("Debugger.newSource");
-            },
+            removeNewSourceListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Debugger.newSource"); },
             /**
@@ -353,5 +337,3 @@ * Find all sources in the recording. Does not return until the recording is
             },
-            removeNewMessageListener: function () {
-                return _this.genericClient.removeEventListener("Console.newMessage");
-            },
+            removeNewMessageListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Console.newMessage"); },
             /**
@@ -549,5 +531,3 @@ * Find all messages in the recording. Does not return until the recording is
             },
-            removeAnalysisResultListener: function () {
-                return _this.genericClient.removeEventListener("Analysis.analysisResult");
-            },
+            removeAnalysisResultListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Analysis.analysisResult"); },
             /**
@@ -561,5 +541,3 @@ * Describes an error that occurred when running an analysis mapper or reducer
             },
-            removeAnalysisErrorListener: function () {
-                return _this.genericClient.removeEventListener("Analysis.analysisError");
-            },
+            removeAnalysisErrorListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Analysis.analysisError"); },
             /**
@@ -571,5 +549,3 @@ * Describes some points at which an analysis will run.
             },
-            removeAnalysisPointsListener: function () {
-                return _this.genericClient.removeEventListener("Analysis.analysisPoints");
-            },
+            removeAnalysisPointsListener: function () { var _a, _b; return (_b = (_a = _this.genericClient).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "Analysis.analysisPoints"); },
             /**
@@ -576,0 +552,0 @@ * Start specifying a new analysis.

js/client/index.d.ts

 export * from "./build/client";
-export * from "./build/generic";
+export * from "./generic";
 export * from "./simple";

js/client/index.js

 "use strict";
+/* Copyright 2020 Record Replay Inc. */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -14,3 +15,3 @@ if (k2 === undefined) k2 = k;
 __exportStar(require("./build/client"), exports);
-__exportStar(require("./build/generic"), exports);
+__exportStar(require("./generic"), exports);
 __exportStar(require("./simple"), exports);

js/client/simple.d.ts

@@ -1,2 +0,3 @@
-import { GenericProtocolClient } from "./build/generic";
+import { CommandMethods, CommandParams, CommandResult, EventMethods, EventParams } from "../protocol";
+import { GenericProtocolClient } from "./generic";
 /**
@@ -17,6 +18,18 @@ * This interface is designed to be compatible with both `WebSocket`
 }
-interface SimpleProtocolClientConstructor {
-    new (webSocket: WebSocket, callbacks: SocketCallbacks, log: (msg: string) => void): GenericProtocolClient;
+export declare type EventListeners = {
+    [M in EventMethods]: (params: EventParams<M>) => void;
+};
+export declare class SimpleProtocolClient implements GenericProtocolClient {
+    private log;
+    private socket;
+    private opened;
+    private eventListeners;
+    private pendingMessages;
+    private nextMessageId;
+    constructor(webSocket: WebSocket, callbacks: SocketCallbacks, log: (msg: string) => void);
+    addEventListener<M extends EventMethods>(event: M, listener: (params: EventParams<M>) => void): void;
+    removeEventListener(event: EventMethods): void;
+    sendCommand<M extends CommandMethods>(method: M, params: CommandParams<M>, sessionId?: string, pauseId?: string): Promise<CommandResult<M>>;
+    private onMessage;
 }
-export declare const SimpleProtocolClient: SimpleProtocolClientConstructor;
 export {};

js/client/simple.js

@@ -41,7 +41,7 @@ "use strict";
 exports.SimpleProtocolClient = void 0;
-exports.SimpleProtocolClient = /** @class */ (function () {
-    function class_1(webSocket, callbacks, log) {
+var SimpleProtocolClient = /** @class */ (function () {
+    function SimpleProtocolClient(webSocket, callbacks, log) {
         var _this = this;
         this.log = log;
-        this.eventListeners = new Map();
+        this.eventListeners = {};
         this.pendingMessages = new Map();
@@ -59,12 +59,12 @@ this.nextMessageId = 1;
     }
-    class_1.prototype.addEventListener = function (event, listener) {
-        if (this.eventListeners.has(event)) {
+    SimpleProtocolClient.prototype.addEventListener = function (event, listener) {
+        if (event in this.eventListeners) {
             throw new Error("Duplicate event listener " + event);
         }
-        this.eventListeners.set(event, listener);
+        this.eventListeners[event] = listener;
     };
-    class_1.prototype.removeEventListener = function (event) {
-        this.eventListeners.delete(event);
+    SimpleProtocolClient.prototype.removeEventListener = function (event) {
+        delete this.eventListeners[event];
     };
-    class_1.prototype.sendCommand = function (method, params, sessionId, pauseId) {
+    SimpleProtocolClient.prototype.sendCommand = function (method, params, sessionId, pauseId) {
         return __awaiter(this, void 0, void 0, function () {
@@ -86,3 +86,3 @@ var id, waiter;
     };
-    class_1.prototype.onMessage = function (msg) {
+    SimpleProtocolClient.prototype.onMessage = function (msg) {
         if (msg.id) {
@@ -99,3 +99,3 @@ var _a = this.pendingMessages.get(msg.id), resolve = _a.resolve, reject = _a.reject;
         else {
-            var handler = this.eventListeners.get(msg.method);
+            var handler = this.eventListeners[msg.method];
             if (handler) {
@@ -109,6 +109,8 @@ handler(msg.params);
     };
-    return class_1;
+    return SimpleProtocolClient;
 }());
+exports.SimpleProtocolClient = SimpleProtocolClient;
 function defer() {
-    var resolve, reject;
+    var resolve;
+    var reject;
     var promise = new Promise(function (res, rej) {
@@ -115,0 +117,0 @@ resolve = res;

js/index.d.ts

 export * from "./protocol";
 export * from "./client";
-export * from "./server";

js/index.js

 "use strict";
+/* Copyright 2020 Record Replay Inc. */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -15,2 +16,1 @@ if (k2 === undefined) k2 = k;
 __exportStar(require("./client"), exports);
-__exportStar(require("./server"), exports);

js/protocol/index.d.ts

@@ -13,1 +13,1015 @@ export * from "./Recording";
 export * from "./Internal";
+import { metadataChange, uploadedData, sessionError, getDescriptionParameters, getDescriptionResult, getMetadataParameters, getMetadataResult, setMetadataParameters, setMetadataResult, metadataStartListeningParameters, metadataStartListeningResult, metadataStopListeningParameters, metadataStopListeningResult, createSessionParameters, createSessionResult, releaseSessionParameters, releaseSessionResult, processRecordingParameters, processRecordingResult } from "./Recording";
+import { setAccessTokenParameters, setAccessTokenResult } from "./Authentication";
+import { missingRegions, unprocessedRegions, mouseEvents, ensureProcessedParameters, ensureProcessedResult, findMouseEventsParameters, findMouseEventsResult, getEndpointParameters, getEndpointResult, createPauseParameters, createPauseResult, releasePauseParameters, releasePauseResult } from "./Session";
+import { paintPoints, findPaintsParameters, findPaintsResult, getPaintContentsParameters, getPaintContentsResult, getDevicePixelRatioParameters, getDevicePixelRatioResult } from "./Graphics";
+import { newSource, findSourcesParameters, findSourcesResult, getSourceContentsParameters, getSourceContentsResult, getPossibleBreakpointsParameters, getPossibleBreakpointsResult, getMappedLocationParameters, getMappedLocationResult, setBreakpointParameters, setBreakpointResult, removeBreakpointParameters, removeBreakpointResult, findResumeTargetParameters, findResumeTargetResult, findRewindTargetParameters, findRewindTargetResult, findReverseStepOverTargetParameters, findReverseStepOverTargetResult, findStepOverTargetParameters, findStepOverTargetResult, findStepInTargetParameters, findStepInTargetResult, findStepOutTargetParameters, findStepOutTargetResult, blackboxSourceParameters, blackboxSourceResult, unblackboxSourceParameters, unblackboxSourceResult } from "./Debugger";
+import { newMessage, findMessagesParameters, findMessagesResult } from "./Console";
+import { evaluateInFrameParameters, evaluateInFrameResult, evaluateInGlobalParameters, evaluateInGlobalResult, getObjectPropertyParameters, getObjectPropertyResult, callFunctionParameters, callFunctionResult, callObjectPropertyParameters, callObjectPropertyResult, getObjectPreviewParameters, getObjectPreviewResult, getScopeParameters, getScopeResult, getTopFrameParameters, getTopFrameResult, getAllFramesParameters, getAllFramesResult, getFrameArgumentsParameters, getFrameArgumentsResult, getFrameStepsParameters, getFrameStepsResult, getExceptionValueParameters, getExceptionValueResult } from "./Pause";
+import { getDocumentParameters, getDocumentResult, getParentNodesParameters, getParentNodesResult, querySelectorParameters, querySelectorResult, getEventListenersParameters, getEventListenersResult, getBoxModelParameters, getBoxModelResult, getBoundingClientRectParameters, getBoundingClientRectResult, getAllBoundingClientRectsParameters, getAllBoundingClientRectsResult, performSearchParameters, performSearchResult } from "./DOM";
+import { getComputedStyleParameters, getComputedStyleResult, getAppliedRulesParameters, getAppliedRulesResult } from "./CSS";
+import { analysisResult, analysisError, analysisPoints, createAnalysisParameters, createAnalysisResult, addLocationParameters, addLocationResult, addFunctionEntryPointsParameters, addFunctionEntryPointsResult, addRandomPointsParameters, addRandomPointsResult, addEventHandlerEntryPointsParameters, addEventHandlerEntryPointsResult, addExceptionPointsParameters, addExceptionPointsResult, runAnalysisParameters, runAnalysisResult, releaseAnalysisParameters, releaseAnalysisResult, findAnalysisPointsParameters, findAnalysisPointsResult } from "./Analysis";
+import { convertLocationToFunctionOffsetParameters, convertLocationToFunctionOffsetResult, convertFunctionOffsetToLocationParameters, convertFunctionOffsetToLocationResult, getStepOffsetsParameters, getStepOffsetsResult, getHTMLSourceParameters, getHTMLSourceResult, getFunctionsInRangeParameters, getFunctionsInRangeResult, getSourceMapURLParameters, getSourceMapURLResult, getSheetSourceMapURLParameters, getSheetSourceMapURLResult, getCurrentMessageContentsParameters, getCurrentMessageContentsResult, countStackFramesParameters, countStackFramesResult, currentGeneratorIdParameters, currentGeneratorIdResult, topFrameLocationParameters, topFrameLocationResult } from "./Target";
+import { createRecordingParameters, createRecordingResult, setRecordingMetadataParameters, setRecordingMetadataResult, addRecordingDataParameters, addRecordingDataResult, addRecordingDescriptionParameters, addRecordingDescriptionResult, hasResourceParameters, hasResourceResult, addResourceParameters, addResourceResult, addRecordingResourceParameters, addRecordingResourceResult, echoParameters, echoResult, labelTestSessionParameters, labelTestSessionResult, getRecordingsParameters, getRecordingsResult, reportCrashParameters, reportCrashResult } from "./Internal";
+interface Events {
+    /**
+     * Describes a change to an entry in a recording's metadata.
+     */
+    "Recording.metadataChange": {
+        parameters: metadataChange;
+        sessionId: false;
+    };
+    /**
+     * Describes how much of a recording's data has been uploaded to the cloud service.
+     */
+    "Recording.uploadedData": {
+        parameters: uploadedData;
+        sessionId: false;
+    };
+    /**
+     * Emitted when a session has died due to a server side problem.
+     */
+    "Recording.sessionError": {
+        parameters: sessionError;
+        sessionId: false;
+    };
+    /**
+     * Event describing regions of the recording that have not been uploaded.
+     */
+    "Session.missingRegions": {
+        parameters: missingRegions;
+        sessionId: true;
+    };
+    /**
+     * Event describing regions of the recording that have not been processed.
+     */
+    "Session.unprocessedRegions": {
+        parameters: unprocessedRegions;
+        sessionId: true;
+    };
+    /**
+     * Describes some mouse events that occur in the recording.
+     */
+    "Session.mouseEvents": {
+        parameters: mouseEvents;
+        sessionId: true;
+    };
+    /**
+     * Describes some points in the recording at which paints occurred. No paint
+     * will occur for the recording's beginning execution point.
+     */
+    "Graphics.paintPoints": {
+        parameters: paintPoints;
+        sessionId: true;
+    };
+    /**
+     * Describes a source in the recording.
+     */
+    "Debugger.newSource": {
+        parameters: newSource;
+        sessionId: true;
+    };
+    /**
+     * Describes a console message in the recording.
+     */
+    "Console.newMessage": {
+        parameters: newMessage;
+        sessionId: true;
+    };
+    /**
+     * Describes some results of an analysis.
+     */
+    "Analysis.analysisResult": {
+        parameters: analysisResult;
+        sessionId: false;
+    };
+    /**
+     * Describes an error that occurred when running an analysis mapper or reducer
+     * function. This will not be emitted for every error, but if there was any
+     * error then at least one event will be emitted.
+     */
+    "Analysis.analysisError": {
+        parameters: analysisError;
+        sessionId: false;
+    };
+    /**
+     * Describes some points at which an analysis will run.
+     */
+    "Analysis.analysisPoints": {
+        parameters: analysisPoints;
+        sessionId: false;
+    };
+}
+export declare type EventMethods = keyof Events;
+export declare type EventParams<P extends EventMethods> = Events[P]["parameters"];
+export declare type EventHasSessionId<P extends EventMethods> = Events[P]["sessionId"];
+interface Commands {
+    /**
+     * Get a description of a recording.
+     */
+    "Recording.getDescription": {
+        parameters: getDescriptionParameters;
+        result: getDescriptionResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get an entry in a recording's metadata key/value store.
+     */
+    "Recording.getMetadata": {
+        parameters: getMetadataParameters;
+        result: getMetadataResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Set an entry in a recording's metadata.
+     */
+    "Recording.setMetadata": {
+        parameters: setMetadataParameters;
+        result: setMetadataResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Listen for changes to an entry in a recording's metadata. When listening,
+     * <code>metadataChange</code> events will be emitted whenever the entry's
+     * value changes.
+     */
+    "Recording.metadataStartListening": {
+        parameters: metadataStartListeningParameters;
+        result: metadataStartListeningResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Stop listening for changes to an entry in a recording's metadata.
+     */
+    "Recording.metadataStopListening": {
+        parameters: metadataStopListeningParameters;
+        result: metadataStopListeningResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Create a session for inspecting a recording. This command does not return
+     * until the recording's contents have been fully received. If the contents
+     * are incomplete, <code>uploadedData</code> events will be periodically
+     * emitted before the command returns. After creating, a <code>sessionError</code>
+     * events may be emitted later if the session dies unexpectedly.
+     */
+    "Recording.createSession": {
+        parameters: createSessionParameters;
+        result: createSessionResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Release a session and allow its resources to be reclaimed.
+     */
+    "Recording.releaseSession": {
+        parameters: releaseSessionParameters;
+        result: releaseSessionResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Begin processing a recording, even if no sessions have been created for it.
+     * After calling this, sessions created for the recording (on this connection,
+     * or another) may start in a partially or fully processed state and start
+     * being used immediately.
+     */
+    "Recording.processRecording": {
+        parameters: processRecordingParameters;
+        result: processRecordingResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Set the user's current access token
+     */
+    "Authentication.setAccessToken": {
+        parameters: setAccessTokenParameters;
+        result: setAccessTokenResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Does not return until the recording is fully processed. Before returning,
+     * <code>missingRegions</code> and <code>unprocessedRegions</code> events will
+     * be periodically emitted. Commands which require inspecting the recording
+     * will not return until that part of the recording has been processed,
+     * see <code>ProcessingLevel</code> for details.
+     */
+    "Session.ensureProcessed": {
+        parameters: ensureProcessedParameters;
+        result: ensureProcessedResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find all points in the recording at which a mouse move or click occurred.
+     * Does not return until the recording is fully processed. Before returning,
+     * <code>mouseEvents</code> events will be periodically emitted. The union
+     * of all these events describes all mouse events in the recording.
+     */
+    "Session.findMouseEvents": {
+        parameters: findMouseEventsParameters;
+        result: findMouseEventsResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the last execution point in the recording.
+     */
+    "Session.getEndpoint": {
+        parameters: getEndpointParameters;
+        result: getEndpointResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Create a pause describing the state at an execution point.
+     */
+    "Session.createPause": {
+        parameters: createPauseParameters;
+        result: createPauseResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Release a pause and allow its resources to be reclaimed.
+     */
+    "Session.releasePause": {
+        parameters: releasePauseParameters;
+        result: releasePauseResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find all points in the recording at which paints occurred. Does not return
+     * until the recording is fully processed. Before returning,
+     * <code>paintPoints</code> events will be periodically emitted. The union
+     * of all these events describes all paint points in the recording.
+     */
+    "Graphics.findPaints": {
+        parameters: findPaintsParameters;
+        result: findPaintsResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the graphics at a point where a paint occurred.
+     */
+    "Graphics.getPaintContents": {
+        parameters: getPaintContentsParameters;
+        result: getPaintContentsResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the value of <code>window.devicePixelRatio</code>. This is the ratio of
+     * pixels in screen shots to pixels used by DOM/CSS data such as
+     * <code>DOM.getBoundingClientRect</code>.
+     */
+    "Graphics.getDevicePixelRatio": {
+        parameters: getDevicePixelRatioParameters;
+        result: getDevicePixelRatioResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find all sources in the recording. Does not return until the recording is
+     * fully processed. Before returning, <code>newSource</code> events will be
+     * emitted for every source in the recording.
+     */
+    "Debugger.findSources": {
+        parameters: findSourcesParameters;
+        result: findSourcesResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the contents of a source.
+     */
+    "Debugger.getSourceContents": {
+        parameters: getSourceContentsParameters;
+        result: getSourceContentsResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get a compact representation of the locations where breakpoints can be set
+     * in a region of a source.
+     */
+    "Debugger.getPossibleBreakpoints": {
+        parameters: getPossibleBreakpointsParameters;
+        result: getPossibleBreakpointsResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the mapped location for a source location.
+     */
+    "Debugger.getMappedLocation": {
+        parameters: getMappedLocationParameters;
+        result: getMappedLocationResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Set a breakpoint at a location.
+     */
+    "Debugger.setBreakpoint": {
+        parameters: setBreakpointParameters;
+        result: setBreakpointResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Remove a breakpoint.
+     */
+    "Debugger.removeBreakpoint": {
+        parameters: removeBreakpointParameters;
+        result: removeBreakpointResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find where to pause when running forward from a point.
+     */
+    "Debugger.findResumeTarget": {
+        parameters: findResumeTargetParameters;
+        result: findResumeTargetResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find where to pause when rewinding from a point.
+     */
+    "Debugger.findRewindTarget": {
+        parameters: findRewindTargetParameters;
+        result: findRewindTargetResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find where to pause when reverse-stepping from a point.
+     */
+    "Debugger.findReverseStepOverTarget": {
+        parameters: findReverseStepOverTargetParameters;
+        result: findReverseStepOverTargetResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find where to pause when stepping from a point.
+     */
+    "Debugger.findStepOverTarget": {
+        parameters: findStepOverTargetParameters;
+        result: findStepOverTargetResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find where to pause when stepping from a point and stopping at the entry of
+     * any encountered call.
+     */
+    "Debugger.findStepInTarget": {
+        parameters: findStepInTargetParameters;
+        result: findStepInTargetResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find where to pause when stepping out from a frame to the caller.
+     */
+    "Debugger.findStepOutTarget": {
+        parameters: findStepOutTargetParameters;
+        result: findStepOutTargetResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Blackbox a source or a region in it. Resume commands like
+     * <code>findResumeTarget</code> will not return execution points in
+     * blackboxed regions of a source.
+     */
+    "Debugger.blackboxSource": {
+        parameters: blackboxSourceParameters;
+        result: blackboxSourceResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Unblackbox a source or a region in it.
+     */
+    "Debugger.unblackboxSource": {
+        parameters: unblackboxSourceParameters;
+        result: unblackboxSourceResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find all messages in the recording. Does not return until the recording is
+     * fully processed. Before returning, <code>newMessage</code> events will be
+     * emitted for every console message in the recording.
+     */
+    "Console.findMessages": {
+        parameters: findMessagesParameters;
+        result: findMessagesResult;
+        sessionId: true;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Evaluate an expression in the context of a call frame. This command is
+     * effectful.
+     */
+    "Pause.evaluateInFrame": {
+        parameters: evaluateInFrameParameters;
+        result: evaluateInFrameResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Evaluate an expression in a global context. This command is effectful.
+     */
+    "Pause.evaluateInGlobal": {
+        parameters: evaluateInGlobalParameters;
+        result: evaluateInGlobalResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Read a property from an object. This command is effectful.
+     */
+    "Pause.getObjectProperty": {
+        parameters: getObjectPropertyParameters;
+        result: getObjectPropertyResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Call a function object. This command is effectful.
+     */
+    "Pause.callFunction": {
+        parameters: callFunctionParameters;
+        result: callFunctionResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Read a property from an object, then call the result. This command is effectful.
+     */
+    "Pause.callObjectProperty": {
+        parameters: callObjectPropertyParameters;
+        result: callObjectPropertyResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Load a preview for an object.
+     */
+    "Pause.getObjectPreview": {
+        parameters: getObjectPreviewParameters;
+        result: getObjectPreviewResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Load a scope's contents.
+     */
+    "Pause.getScope": {
+        parameters: getScopeParameters;
+        result: getScopeResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the topmost frame on the stack.
+     */
+    "Pause.getTopFrame": {
+        parameters: getTopFrameParameters;
+        result: getTopFrameResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get all frames on the stack.
+     */
+    "Pause.getAllFrames": {
+        parameters: getAllFramesParameters;
+        result: getAllFramesResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the values of a frame's arguments.
+     */
+    "Pause.getFrameArguments": {
+        parameters: getFrameArgumentsParameters;
+        result: getFrameArgumentsResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the points of all steps that are executed by a frame.
+     */
+    "Pause.getFrameSteps": {
+        parameters: getFrameStepsParameters;
+        result: getFrameStepsResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get any exception that is being thrown at this point.
+     */
+    "Pause.getExceptionValue": {
+        parameters: getExceptionValueParameters;
+        result: getExceptionValueResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the page's root document.
+     */
+    "DOM.getDocument": {
+        parameters: getDocumentParameters;
+        result: getDocumentResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Load previews for an object and its transitive parents up to the
+     * root document.
+     */
+    "DOM.getParentNodes": {
+        parameters: getParentNodesParameters;
+        result: getParentNodesResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Call querySelector() on a node in the page.
+     */
+    "DOM.querySelector": {
+        parameters: querySelectorParameters;
+        result: querySelectorResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the event listeners attached to a node in the page.
+     */
+    "DOM.getEventListeners": {
+        parameters: getEventListenersParameters;
+        result: getEventListenersResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get boxes for a node.
+     */
+    "DOM.getBoxModel": {
+        parameters: getBoxModelParameters;
+        result: getBoxModelResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the bounding client rect for a node.
+     */
+    "DOM.getBoundingClientRect": {
+        parameters: getBoundingClientRectParameters;
+        result: getBoundingClientRectResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the bounding client rect for all elements on the page.
+     */
+    "DOM.getAllBoundingClientRects": {
+        parameters: getAllBoundingClientRectsParameters;
+        result: getAllBoundingClientRectsResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Search the DOM for nodes containing a string.
+     */
+    "DOM.performSearch": {
+        parameters: performSearchParameters;
+        result: performSearchResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the styles computed for a node.
+     */
+    "CSS.getComputedStyle": {
+        parameters: getComputedStyleParameters;
+        result: getComputedStyleResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Get the style rules being applied to a node.
+     */
+    "CSS.getAppliedRules": {
+        parameters: getAppliedRulesParameters;
+        result: getAppliedRulesResult;
+        sessionId: true;
+        pauseId: true;
+        binary: false;
+    };
+    /**
+     * Start specifying a new analysis.
+     */
+    "Analysis.createAnalysis": {
+        parameters: createAnalysisParameters;
+        result: createAnalysisResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Apply the analysis to every point where a source location executes.
+     */
+    "Analysis.addLocation": {
+        parameters: addLocationParameters;
+        result: addLocationResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Apply the analysis to every function entry point in a region of a source.
+     */
+    "Analysis.addFunctionEntryPoints": {
+        parameters: addFunctionEntryPointsParameters;
+        result: addFunctionEntryPointsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Apply the analysis to a random selection of points.
+     */
+    "Analysis.addRandomPoints": {
+        parameters: addRandomPointsParameters;
+        result: addRandomPointsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Apply the analysis to the entry point of every handler for an event.
+     */
+    "Analysis.addEventHandlerEntryPoints": {
+        parameters: addEventHandlerEntryPointsParameters;
+        result: addEventHandlerEntryPointsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Apply the analysis to every point where an exception is thrown.
+     */
+    "Analysis.addExceptionPoints": {
+        parameters: addExceptionPointsParameters;
+        result: addExceptionPointsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Run the analysis. After this is called, <code>analysisResult</code> and/or
+     * <code>analysisError</code> events will be emitted as results are gathered.
+     * Does not return until the analysis has finished and all events have been
+     * emitted.
+     */
+    "Analysis.runAnalysis": {
+        parameters: runAnalysisParameters;
+        result: runAnalysisResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Release an analysis and its server side resources. If the analysis is
+     * running, it will be canceled, preventing further <code>analysisResult</code>
+     * and <code>analysisError</code> events from being emitted.
+     */
+    "Analysis.releaseAnalysis": {
+        parameters: releaseAnalysisParameters;
+        result: releaseAnalysisResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Find the set of execution points at which an analysis will run. After this
+     * is called, <code>analysisPoints</code> events will be emitted as the points
+     * are found. Does not return until events for all points have been emitted.
+     * Can only be used after the analysis has started running.
+     */
+    "Analysis.findAnalysisPoints": {
+        parameters: findAnalysisPointsParameters;
+        result: findAnalysisPointsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the function ID / offset to use for a source location, if there is one.
+     */
+    "Target.convertLocationToFunctionOffset": {
+        parameters: convertLocationToFunctionOffsetParameters;
+        result: convertLocationToFunctionOffsetResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the location to use for a function ID / offset.
+     */
+    "Target.convertFunctionOffsetToLocation": {
+        parameters: convertFunctionOffsetToLocationParameters;
+        result: convertFunctionOffsetToLocationResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the offsets at which execution should pause when stepping around within
+     * a frame for a function.
+     */
+    "Target.getStepOffsets": {
+        parameters: getStepOffsetsParameters;
+        result: getStepOffsetsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the most complete contents known for an HTML file.
+     */
+    "Target.getHTMLSource": {
+        parameters: getHTMLSourceParameters;
+        result: getHTMLSourceResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the IDs of all functions in a range within a source.
+     */
+    "Target.getFunctionsInRange": {
+        parameters: getFunctionsInRangeParameters;
+        result: getFunctionsInRangeResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get any source map URL associated with a source.
+     */
+    "Target.getSourceMapURL": {
+        parameters: getSourceMapURLParameters;
+        result: getSourceMapURLResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get any source map URL associated with a style sheet.
+     */
+    "Target.getSheetSourceMapURL": {
+        parameters: getSheetSourceMapURLParameters;
+        result: getSheetSourceMapURLResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * This command might be sent from within a RecordReplayOnConsoleMessage() call
+     * to get contents of the new message. Properties in the result have the same
+     * meaning as for <code>Console.Message</code>.
+     */
+    "Target.getCurrentMessageContents": {
+        parameters: getCurrentMessageContentsParameters;
+        result: getCurrentMessageContentsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Count the number of stack frames on the stack. This is equivalent to using
+     * the size of the stack returned by <code>Pause.getAllFrames</code>, but can
+     * be implemented more efficiently.
+     */
+    "Target.countStackFrames": {
+        parameters: countStackFramesParameters;
+        result: countStackFramesResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * If the topmost frame on the stack is a generator frame which can be popped
+     * and pushed on the stack repeatedly, return a unique ID for the frame which
+     * will be consistent across each of those pops and pushes.
+     */
+    "Target.currentGeneratorId": {
+        parameters: currentGeneratorIdParameters;
+        result: currentGeneratorIdResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the location of the top frame on the stack, if there is one.
+     */
+    "Target.topFrameLocation": {
+        parameters: topFrameLocationParameters;
+        result: topFrameLocationResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Create a new recording.
+     */
+    "Internal.createRecording": {
+        parameters: createRecordingParameters;
+        result: createRecordingResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Adds metadata that is associated with the entire recording in question,
+     * as identified by the id field in the recordingData field. This includes things
+     * like the URL being recorded as well as the token that is associated with the
+     * user who started this recording.
+     */
+    "Internal.setRecordingMetadata": {
+        parameters: setRecordingMetadataParameters;
+        result: setRecordingMetadataResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Add data to a recording. The next message sent after this must be a binary
+     * message with the data described by this message. Uploaded recordings are not
+     * explicitly finished; replay sessions created for a recording will include
+     * all data which was successfully uploaded.
+     */
+    "Internal.addRecordingData": {
+        parameters: addRecordingDataParameters;
+        result: addRecordingDataResult;
+        sessionId: false;
+        pauseId: false;
+        binary: true;
+    };
+    /**
+     * Add metadata about a recording.
+     */
+    "Internal.addRecordingDescription": {
+        parameters: addRecordingDescriptionParameters;
+        result: addRecordingDescriptionResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Determine whether a resource is known to the cloud service.
+     */
+    "Internal.hasResource": {
+        parameters: hasResourceParameters;
+        result: hasResourceResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Upload a resource's contents to the cloud service.
+     */
+    "Internal.addResource": {
+        parameters: addResourceParameters;
+        result: addResourceResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Associate a resource with a recording.
+     */
+    "Internal.addRecordingResource": {
+        parameters: addRecordingResourceParameters;
+        result: addRecordingResourceResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * For testing network issues.
+     */
+    "Internal.echo": {
+        parameters: echoParameters;
+        result: echoResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Mark a session which was created for an automated test.
+     */
+    "Internal.labelTestSession": {
+        parameters: labelTestSessionParameters;
+        result: labelTestSessionResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Get the user's recordings
+     */
+    "Internal.getRecordings": {
+        parameters: getRecordingsParameters;
+        result: getRecordingsResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+    /**
+     * Report information about a crash while recording.
+     */
+    "Internal.reportCrash": {
+        parameters: reportCrashParameters;
+        result: reportCrashResult;
+        sessionId: false;
+        pauseId: false;
+        binary: false;
+    };
+}
+export declare type CommandMethods = keyof Commands;
+export declare type CommandParams<P extends CommandMethods> = Commands[P]["parameters"];
+export declare type CommandResult<P extends CommandMethods> = Commands[P]["result"];
+export declare type CommandHasSessionId<P extends CommandMethods> = Commands[P]["sessionId"];
+export declare type CommandHasPauseId<P extends CommandMethods> = Commands[P]["pauseId"];
+export declare type CommandHasBinary<P extends CommandMethods> = Commands[P]["binary"];

js/protocol/index.js

@@ -25,1 +25,3 @@ "use strict";
 __exportStar(require("./Internal"), exports);
+;
+;

package.json

 {
   "name": "@recordreplay/protocol",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Definition of the protocol used by the Record Replay web service",
   "author": "",
   "license": "BSD-3-Clause",
-  "homepage": "https://github.com/RecordReplay/protocol#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/RecordReplay/protocol.git"
-  },
-  "bugs": {
-    "url": "https://github.com/RecordReplay/protocol/issues"
-  },
+  "homepage": "https://replay.io/protocol",
   "files": [
     "js",
-    "json",
     "LICENSE",
@@ -23,16 +15,9 @@ "README.md"
   "scripts": {
-    "build-json": "./build.sh",
-    "build-ts": "ts-node build",
-    "build-js": "tsc",
+    "build-json": "python2 inspector_protocol/convert_protocol_to_json.py pdl/protocol.pdl json/protocol.json",
+    "build-ts": "../../node_modules/.bin/ts-node build",
+    "build-js": "../../node_modules/.bin/tsc",
     "build": "npm run clean && npm run build-json && npm run build-ts && npm run build-js",
-    "clean": "rimraf ts/protocol ts/*/build js",
+    "clean": "../../node_modules/.bin/rimraf json/protocol.json ts/protocol ts/*/build js",
     "prepare": "npm run build"
-  },
-  "devDependencies": {
-    "@types/node": "^14.10.1",
-    "rimraf": "^3.0.2",
-    "ts-node": "^9.0.0",
-    "typescript": "^4.0.2"
-  },
-  "dependencies": {}
+  }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No bug tracker

Maintenance

Package does not have a linked bug tracker in package.json.

Found 1 instance in 1 package

No repository

Supply chain risk

Package does not have a linked source code repository. Without this field, a package will have no reference to the location of the source code use to generate the package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Dev dependency count

0

decreased by-100%

Worsened metrics

Total package byte prevSize

182202

decreased by-53.75%

Number of package files

38

decreased by-17.39%

Lines of code

4787

decreased by-43.26%

Number of low maintenance alerts

2

increased by100%

Number of low supply chain risk alerts

1

increased byInfinity%

No dependency changes