| // Copyright 2017 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import * as Common from '../../core/common/common.js'; |
| import type * as Platform from '../../core/platform/platform.js'; |
| import * as SDK from '../../core/sdk/sdk.js'; |
| import * as Formatter from '../formatter/formatter.js'; |
| import * as TextUtils from '../text_utils/text_utils.js'; |
| import * as Workspace from '../workspace/workspace.js'; |
| |
| import {ContentProviderBasedProject} from './ContentProviderBasedProject.js'; |
| import type {CSSWorkspaceBinding} from './CSSWorkspaceBinding.js'; |
| import type {DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js'; |
| import {NetworkProject} from './NetworkProject.js'; |
| import {resourceMetadata} from './ResourceUtils.js'; |
| |
| const styleSheetRangeMap = new WeakMap<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, TextUtils.TextRange.TextRange>(); |
| const scriptRangeMap = new WeakMap<SDK.Script.Script, TextUtils.TextRange.TextRange>(); |
| const boundUISourceCodes = new WeakSet<Workspace.UISourceCode.UISourceCode>(); |
| |
| function computeScriptRange(script: SDK.Script.Script): TextUtils.TextRange.TextRange { |
| return new TextUtils.TextRange.TextRange(script.lineOffset, script.columnOffset, script.endLine, script.endColumn); |
| } |
| |
| function computeStyleSheetRange(header: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader): TextUtils.TextRange.TextRange { |
| return new TextUtils.TextRange.TextRange(header.startLine, header.startColumn, header.endLine, header.endColumn); |
| } |
| |
| export class ResourceMapping implements SDK.TargetManager.SDKModelObserver<SDK.ResourceTreeModel.ResourceTreeModel> { |
| readonly workspace: Workspace.Workspace.WorkspaceImpl; |
| readonly #modelToInfo = new Map<SDK.ResourceTreeModel.ResourceTreeModel, ModelInfo>(); |
| |
| #debuggerWorkspaceBinding: DebuggerWorkspaceBinding|null = null; |
| #cssWorkspaceBinding: CSSWorkspaceBinding|null = null; |
| |
| constructor(targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl) { |
| this.workspace = workspace; |
| targetManager.observeModels(SDK.ResourceTreeModel.ResourceTreeModel, this); |
| } |
| |
| get debuggerWorkspaceBinding(): DebuggerWorkspaceBinding|null { |
| // TODO(crbug.com/458180550): Throw when this.#debuggerWorkspaceBinding is null and never return null. |
| // The only reason we don't throw and return an instance unconditionally |
| // is that unit tests often don't set-up both the *WorkspaceBindings. |
| return this.#debuggerWorkspaceBinding; |
| } |
| |
| /* {@link DebuggerWorkspaceBinding} and ResourceMapping form a cycle so we can't wire it up at ctor time. */ |
| set debuggerWorkspaceBinding(debuggerWorkspaceBinding: DebuggerWorkspaceBinding) { |
| if (this.#debuggerWorkspaceBinding) { |
| throw new Error('DebuggerWorkspaceBinding already set'); |
| } |
| this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding; |
| } |
| |
| get cssWorkspaceBinding(): CSSWorkspaceBinding|null { |
| // TODO(crbug.com/458180550): Throw when this.#cssWorkspaceBinding is null and never return null. |
| // The only reason we don't throw and return an instance unconditionally |
| // is that unit tests often don't set-up both the *WorkspaceBindings. |
| return this.#cssWorkspaceBinding; |
| } |
| |
| /* {@link CSSWorkspaceBinding} and ResourceMapping form a cycle so we can't wire it up at ctor time. */ |
| set cssWorkspaceBinding(cssWorkspaceBinding: CSSWorkspaceBinding) { |
| if (this.#cssWorkspaceBinding) { |
| throw new Error('CSSWorkspaceBinding already set'); |
| } |
| this.#cssWorkspaceBinding = cssWorkspaceBinding; |
| } |
| |
| modelAdded(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void { |
| const info = new ModelInfo(this, resourceTreeModel); |
| this.#modelToInfo.set(resourceTreeModel, info); |
| } |
| |
| modelRemoved(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void { |
| const info = this.#modelToInfo.get(resourceTreeModel); |
| if (info) { |
| info.dispose(); |
| this.#modelToInfo.delete(resourceTreeModel); |
| } |
| } |
| |
| private infoForTarget(target: SDK.Target.Target): ModelInfo|null { |
| const resourceTreeModel = target.model(SDK.ResourceTreeModel.ResourceTreeModel); |
| return resourceTreeModel ? this.#modelToInfo.get(resourceTreeModel) || null : null; |
| } |
| |
| uiSourceCodeForScript(script: SDK.Script.Script): Workspace.UISourceCode.UISourceCode|null { |
| const info = this.infoForTarget(script.debuggerModel.target()); |
| if (!info) { |
| return null; |
| } |
| |
| const project = info.getProject(); |
| const uiSourceCode = project.uiSourceCodeForURL(script.sourceURL); |
| return uiSourceCode; |
| } |
| |
| cssLocationToUILocation(cssLocation: SDK.CSSModel.CSSLocation): Workspace.UISourceCode.UILocation|null { |
| const header = cssLocation.header(); |
| if (!header) { |
| return null; |
| } |
| const info = this.infoForTarget(cssLocation.cssModel().target()); |
| if (!info) { |
| return null; |
| } |
| const uiSourceCode = info.getProject().uiSourceCodeForURL(cssLocation.url); |
| if (!uiSourceCode) { |
| return null; |
| } |
| const offset = styleSheetRangeMap.get(header) ?? computeStyleSheetRange(header); |
| const lineNumber = cssLocation.lineNumber + offset.startLine - header.startLine; |
| let columnNumber = cssLocation.columnNumber; |
| if (cssLocation.lineNumber === header.startLine) { |
| columnNumber += offset.startColumn - header.startColumn; |
| } |
| return uiSourceCode.uiLocation(lineNumber, columnNumber); |
| } |
| |
| jsLocationToUILocation(jsLocation: SDK.DebuggerModel.Location): Workspace.UISourceCode.UILocation|null { |
| const script = jsLocation.script(); |
| if (!script) { |
| return null; |
| } |
| const info = this.infoForTarget(jsLocation.debuggerModel.target()); |
| if (!info) { |
| return null; |
| } |
| const embedderName = script.embedderName(); |
| if (!embedderName) { |
| return null; |
| } |
| const uiSourceCode = info.getProject().uiSourceCodeForURL(embedderName); |
| if (!uiSourceCode) { |
| return null; |
| } |
| const {startLine, startColumn} = scriptRangeMap.get(script) ?? computeScriptRange(script); |
| let {lineNumber, columnNumber} = jsLocation; |
| if (lineNumber === script.lineOffset) { |
| columnNumber += startColumn - script.columnOffset; |
| } |
| lineNumber += startLine - script.lineOffset; |
| if (script.hasSourceURL) { |
| if (lineNumber === 0) { |
| columnNumber += script.columnOffset; |
| } |
| lineNumber += script.lineOffset; |
| } |
| return uiSourceCode.uiLocation(lineNumber, columnNumber); |
| } |
| |
| uiLocationToJSLocations(uiSourceCode: Workspace.UISourceCode.UISourceCode, lineNumber: number, columnNumber: number): |
| SDK.DebuggerModel.Location[] { |
| if (!boundUISourceCodes.has(uiSourceCode)) { |
| return []; |
| } |
| const target = NetworkProject.targetForUISourceCode(uiSourceCode); |
| if (!target) { |
| return []; |
| } |
| const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel); |
| if (!debuggerModel) { |
| return []; |
| } |
| const locations = []; |
| for (const script of debuggerModel.scripts()) { |
| if (script.embedderName() !== uiSourceCode.url()) { |
| continue; |
| } |
| const range = scriptRangeMap.get(script) ?? computeScriptRange(script); |
| if (!range.containsLocation(lineNumber, columnNumber)) { |
| continue; |
| } |
| let scriptLineNumber = lineNumber; |
| let scriptColumnNumber = columnNumber; |
| if (script.hasSourceURL) { |
| scriptLineNumber -= range.startLine; |
| if (scriptLineNumber === 0) { |
| scriptColumnNumber -= range.startColumn; |
| } |
| } |
| locations.push(debuggerModel.createRawLocation(script, scriptLineNumber, scriptColumnNumber)); |
| } |
| return locations; |
| } |
| |
| uiLocationRangeToJSLocationRanges( |
| uiSourceCode: Workspace.UISourceCode.UISourceCode, |
| textRange: TextUtils.TextRange.TextRange): SDK.DebuggerModel.LocationRange[]|null { |
| if (!boundUISourceCodes.has(uiSourceCode)) { |
| return null; |
| } |
| const target = NetworkProject.targetForUISourceCode(uiSourceCode); |
| if (!target) { |
| return null; |
| } |
| const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel); |
| if (!debuggerModel) { |
| return null; |
| } |
| const ranges = []; |
| for (const script of debuggerModel.scripts()) { |
| if (script.embedderName() !== uiSourceCode.url()) { |
| continue; |
| } |
| const scriptTextRange = scriptRangeMap.get(script) ?? computeScriptRange(script); |
| const range = scriptTextRange.intersection(textRange); |
| if (range.isEmpty()) { |
| continue; |
| } |
| let {startLine, startColumn, endLine, endColumn} = range; |
| if (script.hasSourceURL) { |
| startLine -= range.startLine; |
| if (startLine === 0) { |
| startColumn -= range.startColumn; |
| } |
| endLine -= range.startLine; |
| if (endLine === 0) { |
| endColumn -= range.startColumn; |
| } |
| } |
| const start = debuggerModel.createRawLocation(script, startLine, startColumn); |
| const end = debuggerModel.createRawLocation(script, endLine, endColumn); |
| ranges.push({start, end}); |
| } |
| return ranges; |
| } |
| |
| getMappedLines(uiSourceCode: Workspace.UISourceCode.UISourceCode): Set<number>|null { |
| if (!boundUISourceCodes.has(uiSourceCode)) { |
| return null; |
| } |
| const target = NetworkProject.targetForUISourceCode(uiSourceCode); |
| if (!target) { |
| return null; |
| } |
| const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel); |
| if (!debuggerModel) { |
| return null; |
| } |
| const mappedLines = new Set<number>(); |
| for (const script of debuggerModel.scripts()) { |
| if (script.embedderName() !== uiSourceCode.url()) { |
| continue; |
| } |
| const {startLine, endLine} = scriptRangeMap.get(script) ?? computeScriptRange(script); |
| for (let line = startLine; line <= endLine; ++line) { |
| mappedLines.add(line); |
| } |
| } |
| return mappedLines; |
| } |
| |
| uiLocationToCSSLocations(uiLocation: Workspace.UISourceCode.UILocation): SDK.CSSModel.CSSLocation[] { |
| if (!boundUISourceCodes.has(uiLocation.uiSourceCode)) { |
| return []; |
| } |
| const target = NetworkProject.targetForUISourceCode(uiLocation.uiSourceCode); |
| if (!target) { |
| return []; |
| } |
| const cssModel = target.model(SDK.CSSModel.CSSModel); |
| if (!cssModel) { |
| return []; |
| } |
| return cssModel.createRawLocationsByURL( |
| uiLocation.uiSourceCode.url(), uiLocation.lineNumber, uiLocation.columnNumber); |
| } |
| |
| async functionBoundsAtRawLocation(rawLocation: SDK.DebuggerModel.Location): |
| Promise<Workspace.UISourceCode.UIFunctionBounds|null> { |
| const script = rawLocation.script(); |
| if (!script) { |
| return null; |
| } |
| const info = this.infoForTarget(script.debuggerModel.target()); |
| if (!info) { |
| return null; |
| } |
| const embedderName = script.embedderName(); |
| if (!embedderName) { |
| return null; |
| } |
| const uiSourceCode = info.getProject().uiSourceCodeForURL(embedderName); |
| if (!uiSourceCode) { |
| return null; |
| } |
| |
| let {lineNumber, columnNumber} = rawLocation; |
| lineNumber -= script.lineOffset; |
| if (lineNumber === 0) { |
| columnNumber -= script.columnOffset; |
| } |
| |
| const scopeTreeAndText = script ? await SDK.ScopeTreeCache.scopeTreeForScript(script) : null; |
| if (!scopeTreeAndText) { |
| return null; |
| } |
| |
| // Find the inner-most scope that maps to the given position. |
| |
| const offset = scopeTreeAndText.text.offsetFromPosition(lineNumber, columnNumber); |
| |
| const results = []; |
| (function walk(nodes: Formatter.FormatterWorkerPool.ScopeTreeNode[]) { |
| for (const node of nodes) { |
| if (!(offset >= node.start && offset < node.end)) { |
| continue; |
| } |
| results.push(node); |
| walk(node.children); |
| } |
| })([scopeTreeAndText.scopeTree]); |
| |
| const result = results.findLast( |
| node => node.kind === Formatter.FormatterWorkerPool.ScopeKind.FUNCTION || |
| node.kind === Formatter.FormatterWorkerPool.ScopeKind.ARROW_FUNCTION); |
| if (!result) { |
| return null; |
| } |
| |
| // Map back to positions. |
| const startPosition = scopeTreeAndText.text.positionFromOffset(result.start); |
| const endPosition = scopeTreeAndText.text.positionFromOffset(result.end); |
| |
| startPosition.lineNumber += script.lineOffset; |
| if (startPosition.lineNumber === script.lineOffset) { |
| startPosition.columnNumber += script.columnOffset; |
| } |
| |
| endPosition.lineNumber += script.lineOffset; |
| if (endPosition.lineNumber === script.lineOffset) { |
| endPosition.columnNumber += script.columnOffset; |
| } |
| |
| const name = ''; // TODO(crbug.com/452333154): update ScopeVariableAnalysis to include function name. |
| const range = new TextUtils.TextRange.TextRange( |
| startPosition.lineNumber, startPosition.columnNumber, endPosition.lineNumber, endPosition.columnNumber); |
| return new Workspace.UISourceCode.UIFunctionBounds(uiSourceCode, range, name); |
| } |
| |
| resetForTest(target: SDK.Target.Target): void { |
| const resourceTreeModel = target.model(SDK.ResourceTreeModel.ResourceTreeModel); |
| const info = resourceTreeModel ? this.#modelToInfo.get(resourceTreeModel) : null; |
| if (info) { |
| info.resetForTest(); |
| } |
| } |
| } |
| |
| class ModelInfo { |
| project: ContentProviderBasedProject; |
| readonly #bindings = new Map<string, Binding>(); |
| readonly #cssModel: SDK.CSSModel.CSSModel; |
| readonly #eventListeners: Common.EventTarget.EventDescriptor[]; |
| readonly resourceMapping: ResourceMapping; |
| |
| constructor(resourceMapping: ResourceMapping, resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel) { |
| const target = resourceTreeModel.target(); |
| this.resourceMapping = resourceMapping; |
| this.project = new ContentProviderBasedProject( |
| resourceMapping.workspace, 'resources:' + target.id(), Workspace.Workspace.projectTypes.Network, '', |
| false /* isServiceProject */); |
| NetworkProject.setTargetForProject(this.project, target); |
| |
| const cssModel = target.model(SDK.CSSModel.CSSModel); |
| console.assert(Boolean(cssModel)); |
| this.#cssModel = (cssModel as SDK.CSSModel.CSSModel); |
| for (const frame of resourceTreeModel.frames()) { |
| for (const resource of frame.getResourcesMap().values()) { |
| this.addResource(resource); |
| } |
| } |
| this.#eventListeners = [ |
| resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.ResourceAdded, this.resourceAdded, this), |
| resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameWillNavigate, this.frameWillNavigate, this), |
| resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameDetached, this.frameDetached, this), |
| this.#cssModel.addEventListener( |
| SDK.CSSModel.Events.StyleSheetChanged, |
| event => { |
| void this.styleSheetChanged(event); |
| }, |
| this), |
| ]; |
| } |
| |
| private async styleSheetChanged(event: Common.EventTarget.EventTargetEvent<SDK.CSSModel.StyleSheetChangedEvent>): |
| Promise<void> { |
| const header = this.#cssModel.styleSheetHeaderForId(event.data.styleSheetId); |
| if (!header || !header.isInline || (header.isInline && header.isMutable)) { |
| return; |
| } |
| const binding = this.#bindings.get(header.resourceURL()); |
| if (!binding) { |
| return; |
| } |
| await binding.styleSheetChanged(header, event.data.edit || null); |
| } |
| |
| private acceptsResource(resource: SDK.Resource.Resource): boolean { |
| const resourceType = resource.resourceType(); |
| // Only load selected resource types from resources. |
| if (resourceType !== Common.ResourceType.resourceTypes.Image && |
| resourceType !== Common.ResourceType.resourceTypes.Font && |
| resourceType !== Common.ResourceType.resourceTypes.Document && |
| resourceType !== Common.ResourceType.resourceTypes.Manifest && |
| resourceType !== Common.ResourceType.resourceTypes.Fetch && |
| resourceType !== Common.ResourceType.resourceTypes.XHR) { |
| return false; |
| } |
| |
| // Ignore non-images and non-fonts. |
| if (resourceType === Common.ResourceType.resourceTypes.Image && resource.mimeType && |
| !resource.mimeType.startsWith('image')) { |
| return false; |
| } |
| if (resourceType === Common.ResourceType.resourceTypes.Font && resource.mimeType && |
| !resource.mimeType.includes('font')) { |
| return false; |
| } |
| if ((resourceType === Common.ResourceType.resourceTypes.Image || |
| resourceType === Common.ResourceType.resourceTypes.Font) && |
| Common.ParsedURL.schemeIs(resource.contentURL(), 'data:')) { |
| return false; |
| } |
| return true; |
| } |
| |
| private resourceAdded(event: Common.EventTarget.EventTargetEvent<SDK.Resource.Resource>): void { |
| this.addResource(event.data); |
| } |
| |
| private addResource(resource: SDK.Resource.Resource): void { |
| if (!this.acceptsResource(resource)) { |
| return; |
| } |
| |
| let binding = this.#bindings.get(resource.url); |
| if (!binding) { |
| binding = new Binding(this, resource); |
| this.#bindings.set(resource.url, binding); |
| } else { |
| binding.addResource(resource); |
| } |
| } |
| |
| private removeFrameResources(frame: SDK.ResourceTreeModel.ResourceTreeFrame): void { |
| for (const resource of frame.resources()) { |
| if (!this.acceptsResource(resource)) { |
| continue; |
| } |
| const binding = this.#bindings.get(resource.url); |
| if (!binding) { |
| continue; |
| } |
| if (binding.resources.size === 1) { |
| binding.dispose(); |
| this.#bindings.delete(resource.url); |
| } else { |
| binding.removeResource(resource); |
| } |
| } |
| } |
| |
| private frameWillNavigate(event: Common.EventTarget.EventTargetEvent<SDK.ResourceTreeModel.ResourceTreeFrame>): void { |
| this.removeFrameResources(event.data); |
| } |
| |
| private frameDetached( |
| event: Common.EventTarget.EventTargetEvent<{frame: SDK.ResourceTreeModel.ResourceTreeFrame, isSwap: boolean}>): |
| void { |
| this.removeFrameResources(event.data.frame); |
| } |
| |
| resetForTest(): void { |
| for (const binding of this.#bindings.values()) { |
| binding.dispose(); |
| } |
| this.#bindings.clear(); |
| } |
| |
| dispose(): void { |
| Common.EventTarget.removeEventListeners(this.#eventListeners); |
| for (const binding of this.#bindings.values()) { |
| binding.dispose(); |
| } |
| this.#bindings.clear(); |
| this.project.removeProject(); |
| } |
| |
| getProject(): ContentProviderBasedProject { |
| return this.project; |
| } |
| } |
| |
| class Binding implements TextUtils.ContentProvider.ContentProvider { |
| readonly resources: Set<SDK.Resource.Resource>; |
| readonly #project: ContentProviderBasedProject; |
| readonly #uiSourceCode: Workspace.UISourceCode.UISourceCode; |
| #edits: Array<{ |
| stylesheet: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, |
| edit: SDK.CSSModel.Edit|null, |
| }> = []; |
| |
| readonly #debuggerWorkspaceBinding: DebuggerWorkspaceBinding|null; |
| readonly #cssWorkspaceBinding: CSSWorkspaceBinding|null; |
| |
| constructor(modelInfo: ModelInfo, resource: SDK.Resource.Resource) { |
| this.resources = new Set([resource]); |
| this.#project = modelInfo.project; |
| this.#debuggerWorkspaceBinding = modelInfo.resourceMapping.debuggerWorkspaceBinding; |
| this.#cssWorkspaceBinding = modelInfo.resourceMapping.cssWorkspaceBinding; |
| |
| this.#uiSourceCode = this.#project.createUISourceCode(resource.url, resource.contentType()); |
| boundUISourceCodes.add(this.#uiSourceCode); |
| if (resource.frameId) { |
| NetworkProject.setInitialFrameAttribution(this.#uiSourceCode, resource.frameId); |
| } |
| this.#project.addUISourceCodeWithProvider(this.#uiSourceCode, this, resourceMetadata(resource), resource.mimeType); |
| |
| void Promise.all([ |
| ...this.inlineScripts().map(script => this.#debuggerWorkspaceBinding?.updateLocations(script)), |
| ...this.inlineStyles().map(style => this.#cssWorkspaceBinding?.updateLocations(style)), |
| ]); |
| } |
| |
| private inlineStyles(): SDK.CSSStyleSheetHeader.CSSStyleSheetHeader[] { |
| const target = NetworkProject.targetForUISourceCode(this.#uiSourceCode); |
| const stylesheets: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader[] = []; |
| if (!target) { |
| return stylesheets; |
| } |
| const cssModel = target.model(SDK.CSSModel.CSSModel); |
| if (cssModel) { |
| for (const headerId of cssModel.getStyleSheetIdsForURL(this.#uiSourceCode.url())) { |
| const header = cssModel.styleSheetHeaderForId(headerId); |
| if (header) { |
| stylesheets.push(header); |
| } |
| } |
| } |
| return stylesheets; |
| } |
| |
| private inlineScripts(): SDK.Script.Script[] { |
| const target = NetworkProject.targetForUISourceCode(this.#uiSourceCode); |
| if (!target) { |
| return []; |
| } |
| const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel); |
| if (!debuggerModel) { |
| return []; |
| } |
| return debuggerModel.scripts().filter(script => script.embedderName() === this.#uiSourceCode.url()); |
| } |
| |
| async styleSheetChanged(stylesheet: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, edit: SDK.CSSModel.Edit|null): |
| Promise<void> { |
| this.#edits.push({stylesheet, edit}); |
| if (this.#edits.length > 1) { |
| return; |
| } // There is already a styleSheetChanged loop running |
| |
| const content = await this.#uiSourceCode.requestContentData(); |
| if (!TextUtils.ContentData.ContentData.isError(content)) { |
| await this.innerStyleSheetChanged(content.text); |
| } |
| this.#edits = []; |
| } |
| |
| private async innerStyleSheetChanged(content: string): Promise<void> { |
| const scripts = this.inlineScripts(); |
| const styles = this.inlineStyles(); |
| let text: TextUtils.Text.Text = new TextUtils.Text.Text(content); |
| for (const data of this.#edits) { |
| const edit = data.edit; |
| if (!edit) { |
| continue; |
| } |
| const stylesheet = data.stylesheet; |
| const startLocation = styleSheetRangeMap.get(stylesheet) ?? computeStyleSheetRange(stylesheet); |
| |
| const oldRange = edit.oldRange.relativeFrom(startLocation.startLine, startLocation.startColumn); |
| const newRange = edit.newRange.relativeFrom(startLocation.startLine, startLocation.startColumn); |
| text = new TextUtils.Text.Text(text.replaceRange(oldRange, edit.newText)); |
| const updatePromises = []; |
| for (const script of scripts) { |
| const range = scriptRangeMap.get(script) ?? computeScriptRange(script); |
| if (!range.follows(oldRange)) { |
| continue; |
| } |
| scriptRangeMap.set(script, range.rebaseAfterTextEdit(oldRange, newRange)); |
| updatePromises.push(this.#debuggerWorkspaceBinding?.updateLocations(script)); |
| } |
| for (const style of styles) { |
| const range = styleSheetRangeMap.get(style) ?? computeStyleSheetRange(style); |
| if (!range.follows(oldRange)) { |
| continue; |
| } |
| styleSheetRangeMap.set(style, range.rebaseAfterTextEdit(oldRange, newRange)); |
| updatePromises.push(this.#cssWorkspaceBinding?.updateLocations(style)); |
| } |
| await Promise.all(updatePromises); |
| } |
| this.#uiSourceCode.addRevision(text.value()); |
| } |
| |
| addResource(resource: SDK.Resource.Resource): void { |
| this.resources.add(resource); |
| if (resource.frameId) { |
| NetworkProject.addFrameAttribution(this.#uiSourceCode, resource.frameId); |
| } |
| } |
| |
| removeResource(resource: SDK.Resource.Resource): void { |
| this.resources.delete(resource); |
| if (resource.frameId) { |
| NetworkProject.removeFrameAttribution(this.#uiSourceCode, resource.frameId); |
| } |
| } |
| |
| dispose(): void { |
| this.#project.removeUISourceCode(this.#uiSourceCode.url()); |
| void Promise.all([ |
| ...this.inlineScripts().map(script => this.#debuggerWorkspaceBinding?.updateLocations(script)), |
| ...this.inlineStyles().map(style => this.#cssWorkspaceBinding?.updateLocations(style)), |
| ]); |
| } |
| |
| private firstResource(): SDK.Resource.Resource { |
| console.assert(this.resources.size > 0); |
| return this.resources.values().next().value as SDK.Resource.Resource; |
| } |
| |
| contentURL(): Platform.DevToolsPath.UrlString { |
| return this.firstResource().contentURL(); |
| } |
| |
| contentType(): Common.ResourceType.ResourceType { |
| return this.firstResource().contentType(); |
| } |
| |
| requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError> { |
| return this.firstResource().requestContentData(); |
| } |
| |
| searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): |
| Promise<TextUtils.ContentProvider.SearchMatch[]> { |
| return this.firstResource().searchInContent(query, caseSensitive, isRegex); |
| } |
| } |
