roku-debug 0.12.2 → 0.13.0

package/dist/managers/BreakpointManager.d.ts

@@ -12,16 +12,14 @@ export declare class BreakpointManager {
         rootDir: string;
         enableSourceMaps?: boolean;
     };
+    private emitter;
+    private emit;
     /**
-     * Tell the breakpoint manager that no new breakpoints can be verified
-     * (most likely due to the app being launched and roku not supporting dynamic breakpoints)
+     * Subscribe to an event
      */
-    lockBreakpoints(): void;
-    /**
-     * Indicates whether the app has been launched or not.
-     * This will determine whether the breakpoints should be written to the files, or marked as not verified (greyed out in vscode)
-     */
-    private areBreakpointsLocked;
+    on(eventName: 'breakpoints-verified', handler: (data: {
+        breakpoints: AugmentedSourceBreakpoint[];
+    }) => any): any;
     /**
      * A map of breakpoints by what file they were set in.
      * This does not handle any source-to-dest mapping...these breakpoints are stored in the file they were set in.
@@ -29,17 +27,47 @@ export declare class BreakpointManager {
      * (this concept may need to be modified once we get live breakpoint support)
      */
     private breakpointsByFilePath;
-    static breakpointIdSequence: number;
+    /**
+     * A sequence used to generate unique client breakpoint IDs
+     */
+    private breakpointIdSequence;
     /**
      * breakpoint lines are 1-based, and columns are zero-based
      */
-    registerBreakpoint(sourceFilePath: string, breakpoint: AugmentedSourceBreakpoint | DebugProtocol.SourceBreakpoint): void;
+    setBreakpoint(srcPath: string, breakpoint: AugmentedSourceBreakpoint | DebugProtocol.SourceBreakpoint): AugmentedSourceBreakpoint;
+    /**
+     * Find a breakpoint by its hash
+     * @returns the breakpoint, or undefined if not found
+     */
+    private getBreakpointByHash;
+    /**
+     * Find a list of breakpoints by their hashes
+     * @returns the breakpoint, or undefined if not found
+     */
+    private getBreakpointsByHashes;
+    /**
+     * Mark this breakpoint as verified
+     */
+    verifyBreakpoint(hash: string, deviceId: number): void;
+    /**
+     * Whenever breakpoints get verified, they need to be synced back to vscode.
+     * This queues up a future function that will emit a batch of all verified breakpoints.
+     * @param hash the breakpoint hash that identifies this specific breakpoint based on its features
+     */
+    private queueVerifyEvent;
+    private verifiedBreakpointKeys;
+    private isVerifyEventQueued;
+    /**
+     * Generate a key based on the features of the breakpoint. Every breakpoint that exists at the same location
+     * and has the same features should have the same key.
+     */
+    getBreakpointKey(filePath: string, breakpoint: DebugProtocol.SourceBreakpoint | AugmentedSourceBreakpoint): string;
     /**
      * Set/replace/delete the list of breakpoints for this file.
-     * @param sourceFilePath
+     * @param srcPath
      * @param allBreakpointsForFile
      */
-    replaceBreakpoints(sourceFilePath: string, allBreakpointsForFile: DebugProtocol.SourceBreakpoint[]): AugmentedSourceBreakpoint[];
+    replaceBreakpoints(srcPath: string, allBreakpointsForFile: DebugProtocol.SourceBreakpoint[]): AugmentedSourceBreakpoint[];
     /**
      * Get a list of all breakpoint tasks that should be performed.
      * This will also exclude files with breakpoints that are not in scope.
@@ -53,6 +81,11 @@ export declare class BreakpointManager {
      * Write "stop" lines into source code for each breakpoint of each file in the given project
      */
     writeBreakpointsForProject(project: Project): Promise<void>;
+    private registerPermanentBreakpoint;
+    /**
+     * The list of breakpoints that were permanently written to a file at the start of a debug session. Used for line offset calculations.
+     */
+    private permanentBreakpointsBySrcPath;
     /**
      * Write breakpoints to the specified file, and update the sourcemaps to match
      */
@@ -63,48 +96,117 @@ export declare class BreakpointManager {
     /**
      * Get the list of breakpoints for the specified file path, or an empty array
      */
-    getBreakpointsForFile(filePath: string): AugmentedSourceBreakpoint[];
+    private getBreakpointsForFile;
+    /**
+     * Get the permanent breakpoint with the specified hash
+     * @returns the breakpoint with the matching hash, or undefined
+     */
+    getPermanentBreakpoint(hash: string): BreakpointWorkItem;
+    /**
+     * Get the list of breakpoints that were written to the source file
+     */
+    getPermanentBreakpointsForFile(srcPath: string): BreakpointWorkItem[];
     /**
      * File paths can be different casing sometimes,
      * so find the existing key if it exists, or return the file path if it doesn't exist
      */
     sanitizeSourceFilePath(filePath: string): string;
+    /**
+     * Determine if there's a breakpoint set at the given staging folder and line.
+     * This is not trivial, so only run when absolutely necessary
+     * @param projects the list of projects to scan
+     * @param pkgPath the path to the file in the staging directory
+     * @param line the 0-based line for the breakpoint
+     */
+    lineHasBreakpoint(projects: Project[], pkgPath: string, line: number): Promise<boolean>;
+    /**
+     * Get a diff of all breakpoints that have changed since the last time the diff was retrieved.
+     * Sets the new baseline to the current state, so the next diff will be based on this new baseline.
+     *
+     * All projects should be passed in every time.
+     */
+    getDiff(projects: Project[]): Promise<Diff>;
+    /**
+     * Flag indicating whether a `getDiff` function is currently running
+     */
+    private isGetDiffRunning;
+    private lastState;
+}
+export interface Diff {
+    added: BreakpointWorkItem[];
+    removed: BreakpointWorkItem[];
+    unchanged: BreakpointWorkItem[];
 }
-interface AugmentedSourceBreakpoint extends DebugProtocol.SourceBreakpoint {
+export interface AugmentedSourceBreakpoint extends DebugProtocol.SourceBreakpoint {
     /**
-     * An ID for this breakpoint, which is used to set/unset breakpoints in the client
+     * The path to the source file where this breakpoint was originally set
      */
-    id: number;
+    srcPath: string;
+    /**
+     * A unique hash generated for the breakpoint at this exact file/line/column/feature. Every breakpoint with these same features should get the same hash
+     */
+    hash: string;
     /**
-     * Was this breakpoint added before launch? That means this breakpoint was written into the source code as a `stop` statement,
-     * so if users toggle this breakpoint line on and off, it should get verified every time.
+     * The device-provided breakpoint id. A missing ID means this breakpoint has not yet been verified by the device.
      */
-    wasAddedBeforeLaunch: boolean;
+    deviceId?: number;
+    /**
+     * A unique ID the debug adapter generates to help send updates to the client about this breakpoint
+     */
+    id: number;
     /**
      * This breakpoint has been verified (i.e. we were able to set it at the given location)
      */
     verified: boolean;
+}
+export interface BreakpointWorkItem {
     /**
-     * Since breakpoints are written into the source code, we can't delete the `wasAddedBeforeLaunch` breakpoints,
-     * otherwise the non-sourcemap debugging process's line offsets could get messed up. So, for the `wasAddedBeforeLaunch`
-     * breakpoints, we need to mark them as hidden when the user unsets them.
+     * The path to the source file where this breakpoint was originally set
+     */
+    srcPath: string;
+    /**
+     * The absolute path to the file in the staging folder
      */
-    isHidden: boolean;
-}
-interface BreakpointWorkItem {
-    sourceFilePath: string;
     stagingFilePath: string;
+    /**
+     * The device path (i.e. `pkg:/source/main.brs`)
+     */
+    pkgPath: string;
+    /**
+     * The path to the rootDir for this breakpoint
+     */
     rootDirFilePath: string;
     /**
      * The 1-based line number
      */
     line: number;
+    /**
+     * The device-provided breakpoint id. A missing ID means this breakpoint has not yet been verified by the device.
+     */
+    deviceId?: number;
+    /**
+     * An id generated by the debug adapter used to identify this breakpoint in the client
+     */
+    id: number;
+    /**
+     * A unique hash generated for the breakpoint at this exact file/line/column/feature. Every breakpoint with these same features should get the same hash
+     */
+    hash: string;
     /**
      * The 0-based column index
      */
     column: number;
+    /**
+     * If set, this breakpoint will only activate when this condition evaluates to true
+     */
     condition?: string;
+    /**
+     * If set, this breakpoint will only activate once the breakpoint has been hit this many times.
+     */
     hitCondition?: string;
+    /**
+     * If set, this breakpoint will emit a log message at runtime and will not actually stop at the breakpoint
+     */
     logMessage?: string;
     /**
      * `sourceMap` means derived from a source map.
@@ -113,4 +215,3 @@ interface BreakpointWorkItem {
      */
     type: 'fileMap' | 'sourceDirs' | 'sourceMap';
 }
-export {};