bmd-extension 1.6.3

package/src/extension.ts

@@ -0,0 +1,459 @@
+import * as vscode from 'vscode'
+import { ControllerActionProvider } from './provider/codeAction/controller/codeAction';
+import { ServiceActionProvider, ServiceAction } from './provider/codeAction/service/codeAction';
+import { EntityActionProvider } from './provider/codeAction/entity/codeAction';
+import { EntityRequestActionProvider, EntityRequestAction } from './provider/codeAction/entity-request/codeAction';
+import { EntityAction, BMDCommand, Deploy, ControllerAction, ConstructorFunction } from './constant';
+import { insertBuilderRelation } from './provider/codeAction/entity/handleBuilder';
+import { insertEntityFunction, insertQueryBuilder, insertFindOneOrThrow, insertPropertiesToQuery } from './provider/codeAction/entity/handleFunction';
+import { addConfiguration } from './provider/treeDataProvider/module/command/configuration';
+import { insertControllerFunc } from './provider/treeDataProvider/controller/command/handleMethod';
+import { insertPrivateService } from './provider/treeDataProvider/service/command/handleConstructor';
+import { handleDeploy, runDev, runStart } from './provider/treeDataProvider/deploy/command/handleDeploy';
+import { createControllerResource, createControllerNormal } from './provider/treeDataProvider/controller/command/createController';
+import { createService } from './provider/treeDataProvider/service/command/createService';
+import { createEntity } from './provider/treeDataProvider/entity/command/createEntity';
+import { createEntityRequest } from './provider/treeDataProvider/entity/command/createEntityRequest';
+import { CompletionPropertyProvider, CompletionEntityProvider, CompletionQueryProvider } from './provider/completion/CompletionProvider';
+import { updateDiagnostics } from './provider/errorChecking/errorChecking';
+import { TreeProviderCommand } from './provider/treeDataProvider/TreeProviderCommand';
+import { addProperty } from './provider/treeDataProvider/entity/command/addProperty';
+import { insertEntityAction } from './provider/treeDataProvider/entity/command/addRelation';
+import { createInterface } from './provider/treeDataProvider/entity/command/exportInterface';
+import { initProject } from './provider/treeDataProvider/module/command/initProject';
+import { addContentDefine } from './provider/treeDataProvider/module/command/contentDefine';
+import { handleAddPathParams } from './provider/codeAction/controller/addPathParams';
+import { handleAddTokenParams } from './provider/codeAction/controller/addTokenParam';
+import { handleAddValidation } from './provider/codeAction/controller/addValidation';
+import { TreeProviderProject } from './provider/treeDataProvider/TreeProviderProject';
+import { addProjectName } from './provider/treeDataProvider/project/command/addProjectName';
+import { getProjectDetails } from './provider/treeDataProvider/project/command/getProjectDetails';
+import { addEnum, EnumActionProvider } from './provider/codeAction/enum/codeAction';
+import { createApi } from './provider/treeDataProvider/api/createApi';
+
+let deploySB: vscode.StatusBarItem;
+let devSB: vscode.StatusBarItem;
+let runStartSB: vscode.StatusBarItem
+const serviceProvider = new ServiceActionProvider()
+const entityRequestProvider = new EntityRequestActionProvider()
+
+export function activate({ subscriptions }: vscode.ExtensionContext) {
+	// create a new status bar item that we can now manage
+
+	runStartSB = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 203);
+	runStartSB.text = 'RUN START';
+	runStartSB.command = Deploy.RunStart;
+	runStartSB.show();
+
+	//
+	devSB = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 202);
+	devSB.command = Deploy.RunDev;
+	devSB.text = 'RUN DEV'
+	devSB.show()
+
+	//
+	deploySB = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 201);
+	deploySB.command = Deploy.Deploy;
+
+	deploySB.text = 'DEPLOY V2'
+	deploySB.show()
+	//
+
+
+	/**
+	 * *********************************************************
+	 *  						TREE DATA
+	 * *********************************************************
+	 */
+
+	//#region 
+	const bmdCommand = new TreeProviderCommand(vscode.workspace.rootPath);
+
+	vscode.window.registerTreeDataProvider('bmdextension1', bmdCommand);
+	vscode.window.registerTreeDataProvider('bmdextension2', bmdCommand);
+
+	const bmdProject = new TreeProviderProject(vscode.workspace.rootPath)
+	vscode.window.registerTreeDataProvider('bmdprojects', bmdProject);
+	/**
+	 *  TREE DATA - ENTITY
+	 */
+
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.GetProjectDetails, async (projectName) => await getProjectDetails(projectName, subscriptions)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.AddProjectName, async () => await addProjectName()
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.CreateEntity, async (doc) => {
+			const fsPath = doc.fsPath
+			await createEntity(fsPath)
+		}
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.CreateEntityRequest,
+		async (doc) => {
+			const fsPath = doc.fsPath
+			await createEntityRequest(fsPath)
+		}
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityRequestAction.AddProperty,
+		async (doc) => entityRequestProvider.addProperty(doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.AddProperty,
+		async (doc) => addProperty(doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.OneToMany,
+		async (doc) => insertEntityAction(EntityAction.OneToMany, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.ManyToOne,
+		async (doc) => insertEntityAction(EntityAction.ManyToOne, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.ManyToMany,
+		async (doc) => insertEntityAction(EntityAction.ManyToMany, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.OneToOne,
+		async (doc) => insertEntityAction(EntityAction.OneToOne, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.ExportInterface,
+		async (doc, range) => createInterface(doc, range)
+	));
+
+	/**
+	 *  TREE DATA - CONTROLLER
+	 */
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.CreateController,
+		async (doc) => {
+			const fsPath = doc.fsPath
+			await createControllerNormal(fsPath)
+		}
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.CreateControllerResource,
+		async (doc) => {
+			const fsPath = doc.fsPath
+			await createControllerResource(fsPath)
+		}
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.Get,
+		async (doc) => insertControllerFunc(ControllerAction.Get, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.Post,
+		async (doc) => insertControllerFunc(ControllerAction.Post, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.GetListPagination,
+		async (doc) => insertControllerFunc(ControllerAction.GetListPagination, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.GetListAll,
+		async (doc) => insertControllerFunc(ControllerAction.GetListAll, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.CreateItem,
+		async (doc) => insertControllerFunc(ControllerAction.CreateItem, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.CreateItemEntityRequest,
+		async (doc) => insertControllerFunc(ControllerAction.CreateItemEntityRequest, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.UpdateItem,
+		async (doc) => insertControllerFunc(ControllerAction.UpdateItem, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.DeleteItemByRemove,
+		async (doc) => insertControllerFunc(ControllerAction.DeleteItemByRemove, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.DeleteItemByBlock,
+		async (doc) => insertControllerFunc(ControllerAction.DeleteItemByBlock, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.Upload,
+		async (doc) => insertControllerFunc(ControllerAction.Upload, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.UploadResize,
+		async (doc) => insertControllerFunc(ControllerAction.UploadResize, doc)
+	));
+
+	/**
+	 *  TREE DATA - CREATE API
+	 */
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.CreateApi,
+		async (doc) => {
+			const fsPath = doc.fsPath
+			await createApi(fsPath)
+		}
+	));
+
+	/**
+	 *  TREE DATA - SERVICE
+	 */
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.CreateService,
+		async (doc) => {
+			const fsPath = doc.fsPath
+			await createService(fsPath)
+		}
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ConstructorFunction.PrivateService,
+		async (doc) => await insertPrivateService(ConstructorFunction.PrivateService, doc)
+	));
+
+	/**
+	 *  TREE DATA - MODULE
+	 */
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.Init,
+		async () => await initProject()
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.AddModuleContentDefine,
+		async () => await addContentDefine()
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.AddModuleConfiguration,
+		async () => await addConfiguration()
+	));
+
+	/**
+	 *  TREE DATA - DEPLOY
+	 */
+
+	console.log('register Deploy.Deploy command');
+
+	subscriptions.push(vscode.commands.registerCommand(
+		Deploy.Deploy,
+		() => handleDeploy()
+	));
+
+
+	subscriptions.push(vscode.commands.registerCommand(
+		Deploy.RunDev,
+		() => runDev()
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		Deploy.RunStart,
+		() => runStart()
+	));
+
+	//#endregion
+
+
+	/**
+	 * *********************************************************
+	 *  					ERROR CHECKING
+	 * *********************************************************
+	 */
+	//#region 
+	const collection = vscode.languages.createDiagnosticCollection('checkParamsValidator');
+
+	if (vscode.window.activeTextEditor) {
+		updateDiagnostics(vscode.window.activeTextEditor.document, collection);
+	}
+
+	subscriptions.push(vscode.workspace.onDidChangeTextDocument(event => {
+		if (event) updateDiagnostics(event.document, collection);
+	}))
+
+	subscriptions.push(vscode.window.onDidChangeActiveTextEditor(editor => {
+		if (editor) updateDiagnostics(editor.document, collection);
+	}));
+	//#endregion
+
+
+	/**
+	 * *********************************************************
+	 *  					CODE ACTION
+	 * *********************************************************
+	 */
+	//#region 
+	/**
+	 *  CODE ACTION - CONTROLLER
+	 */
+
+	subscriptions.push(vscode.languages.registerCodeActionsProvider(
+		'typescript',
+		new ControllerActionProvider(),
+		{ providedCodeActionKinds: ControllerActionProvider.providedCodeActionKinds }
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.AddPathParams,
+		async (doc, range) => handleAddPathParams(doc, range)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.AddTokenParam,
+		async (doc, range) => handleAddTokenParams(doc, range)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ControllerAction.AddValidation,
+		async (doc, range) => handleAddValidation(doc, range)
+	));
+
+	/**
+	 *  CODE ACTION - SERVICE
+	 */
+
+	subscriptions.push(
+		vscode.languages.registerCodeActionsProvider(
+			'typescript',
+			new ServiceActionProvider(),
+			{ providedCodeActionKinds: ServiceActionProvider.providedCodeActionKinds }
+		)
+	);
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ServiceAction.GetLast30,
+		async (doc) => serviceProvider.insertServiceFunc(ServiceAction.GetLast30, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ServiceAction.GetSum,
+		async (doc) => await serviceProvider.insertServiceFunc(ServiceAction.GetSum, doc)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		ServiceAction.GetManyAndCount,
+		async (doc) => serviceProvider.insertServiceFunc(ServiceAction.GetManyAndCount, doc)
+	));
+
+	/**
+	 *  CODE ACTION - ENTITY
+	 */
+
+	subscriptions.push(
+		vscode.languages.registerCodeActionsProvider(
+			'typescript',
+			new EntityActionProvider(),
+			{ providedCodeActionKinds: EntityActionProvider.providedCodeActionKinds }
+		)
+	);
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.AddRelation,
+		async (doc, range) => insertEntityFunction(EntityAction.AddRelation, doc, range)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.CreateQueryBuilderPagination,
+		async (doc, range) => insertQueryBuilder(EntityAction.CreateQueryBuilderPagination, doc, range)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.CreateQueryBuilderFindAll,
+		async (doc, range) => insertQueryBuilder(EntityAction.CreateQueryBuilderFindAll, doc, range)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.CreateQueryBuilderFindOne,
+		async (doc, range) => insertQueryBuilder(EntityAction.CreateQueryBuilderFindOne, doc, range)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.FindOneOrThrowID,
+		async (doc, range) => insertFindOneOrThrow(EntityAction.FindOneOrThrowID, doc, range)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.AddPropertyToQuery,
+		async (doc, range, lastIndex, property) => insertPropertiesToQuery(doc, range, lastIndex, property)
+	));
+
+	subscriptions.push(vscode.commands.registerCommand(
+		EntityAction.AddBuilderRelation,
+		async (doc, range) => insertBuilderRelation(EntityAction.AddBuilderRelation, doc, range)
+	));
+
+
+	/**
+	 *  CODE ACTION - ENTITY REQUEST
+	 */
+
+	subscriptions.push(vscode.languages.registerCodeActionsProvider(
+		'typescript',
+		new EntityRequestActionProvider(),
+		{ providedCodeActionKinds: EntityRequestActionProvider.providedCodeActionKinds }
+	));
+
+	/**
+	 *  CODE ACTION - ENUM
+	 */
+
+	subscriptions.push(
+		vscode.languages.registerCodeActionsProvider(
+			'typescript',
+			new EnumActionProvider(),
+			{ providedCodeActionKinds: EnumActionProvider.providedCodeActionKinds }
+		)
+	);
+
+	subscriptions.push(vscode.commands.registerCommand(
+		BMDCommand.AddEnum,
+		async (doc, range) => addEnum(doc, range)
+	));
+
+	//#endregion
+
+
+	/**
+	 * *********************************************************
+	 *  						COMPLETION
+	 * *********************************************************
+	 */
+	subscriptions.push(
+		CompletionEntityProvider,
+		CompletionPropertyProvider,
+		CompletionQueryProvider
+	)
+
+}
+
+export function deactivate() { }

package/src/provider/codeAction/controller/addPathParams.ts

@@ -0,0 +1,65 @@
+import * as vscode from 'vscode';
+import { ControllerAction } from '../../../constant';
+import { getPath, getPathParams, getLineCloseFunction } from './util';
+import { getParamLinesInFunction, getParams } from '../../errorChecking/util';
+
+export function addPathParams(document: vscode.TextDocument, range: vscode.Range) {
+    const line = document.lineAt(range.start)
+    if (isControllerFile(document) && isMethodDecorator(line.text)) {
+        console.log('isControllerFile(document) && isMethodDecorator(line.text):', isControllerFile(document) && isMethodDecorator(line.text))
+        const action = new vscode.CodeAction(ControllerAction.AddPathParams, vscode.CodeActionKind.QuickFix);
+
+        action.command = {
+            command: ControllerAction.AddPathParams,
+            title: 'Add @PathParams: ',
+            tooltip: 'Add @PathParams: ',
+            arguments: [document, range]
+        };
+
+        return action;
+    } else {
+        return undefined
+    }
+
+}
+
+function isMethodDecorator(line: string) {
+    return line.includes('@Get') ||
+        line.includes('@Post') ||
+        line.includes('@Delete') ||
+        line.includes('@Put') ||
+        line.includes('@Patch')
+}
+
+function isControllerFile(document: vscode.TextDocument) {
+    return document.fileName.includes('Controller')
+}
+
+export async function handleAddPathParams(document: vscode.TextDocument, range: vscode.Range) {
+    const line = document.lineAt(range.start)
+
+    const path = getPath(line.text)
+    if (!path) return vscode.window.showInformationMessage('Cancel: Can not find path.')
+
+    const pathParams = getPathParams(path)
+    if (!pathParams.length) return vscode.window.showInformationMessage('Cancel: Can not find path params with pattern: ":param".')
+
+    const paramLines = getParamLinesInFunction(line.lineNumber, document)
+    const params = paramLines.map(l => getParams(l.text)).filter(Boolean)
+
+    const notExistParams = pathParams.filter(p => !params.includes(p));
+    if (!notExistParams.length) return vscode.window.showInformationMessage('Cancel: All params were existed.')
+
+    const param = await vscode.window.showQuickPick(notExistParams, { ignoreFocusOut: true })
+
+    if (!param) return vscode.window.showInformationMessage('Cancel: Do not select path params.')
+
+    const edit = new vscode.WorkspaceEdit();
+
+    const template = `        @PathParams("${param}") ${param}: number,
+`
+    const lineCloseFunc = getLineCloseFunction(line, document)
+    edit.insert(document.uri, new vscode.Position(lineCloseFunc.lineNumber, 0), template);
+
+    vscode.workspace.applyEdit(edit)
+}

package/src/provider/codeAction/controller/addTokenParam.ts

@@ -0,0 +1,43 @@
+import * as vscode from 'vscode';
+import { ControllerAction } from '../../../constant';
+import { getLineOpenFunction } from './util';
+
+export function addTokenParam(document: vscode.TextDocument, range: vscode.Range) {
+    const line = document.lineAt(range.start)
+    if (isControllerFile(document) && isUseAuthDecorator(line.text)) {
+        const action = new vscode.CodeAction(ControllerAction.AddTokenParam, vscode.CodeActionKind.QuickFix);
+
+        action.command = {
+            command: ControllerAction.AddTokenParam,
+            title: 'Add token param 1',
+            tooltip: 'Add token param 2',
+            arguments: [document, range],
+        };
+
+        return action;
+    } else {
+        return undefined
+    }
+
+}
+
+function isUseAuthDecorator(line: string) {
+    return line.includes('@UseAuth')
+}
+
+function isControllerFile(document: vscode.TextDocument) {
+    return document.fileName.includes('Controller')
+}
+
+export function handleAddTokenParams(document: vscode.TextDocument, range: vscode.Range) {
+    const line = document.lineAt(range.start)
+
+    const edit = new vscode.WorkspaceEdit();
+
+    const template = `        @HeaderParams("token") token: string,
+`
+    const lineOpenFunc = getLineOpenFunction(line, document)
+    edit.insert(document.uri, new vscode.Position(lineOpenFunc.lineNumber + 1, 0), template);
+
+    vscode.workspace.applyEdit(edit)
+}

package/src/provider/codeAction/controller/addValidation.ts

@@ -0,0 +1,47 @@
+import * as vscode from 'vscode';
+import { ControllerAction } from '../../../constant';
+import { getPath, getPathParams, getLineCloseFunction } from './util';
+import { getParamLinesInFunction, getParams } from '../../errorChecking/util';
+
+export function addValidationRequired(document: vscode.TextDocument, range: vscode.Range) {
+    const line = document.lineAt(range.start)
+    if (isControllerFile(document) && isParamsDecorator(line.text)) {
+        const action = new vscode.CodeAction(ControllerAction.AddValidation, vscode.CodeActionKind.QuickFix);
+
+        action.command = {
+            command: ControllerAction.AddValidation,
+            title: 'Validation',
+            arguments: [document, range]
+        };
+
+        return action;
+    } else {
+        return undefined
+    }
+
+}
+
+function isParamsDecorator(line: string) {
+    return line.includes('@') && line.includes('Params')
+}
+
+function isControllerFile(document: vscode.TextDocument) {
+    return document.fileName.includes('Controller')
+}
+
+export async function handleAddValidation(document: vscode.TextDocument, range: vscode.Range) {
+    const line = document.lineAt(range.start)
+    console.log('line:', line)
+
+    const param = getParams(line.text)
+    return
+
+    const edit = new vscode.WorkspaceEdit();
+
+    const template = `        @PathParams("${param}") ${param}: number,
+`
+    const lineCloseFunc = getLineCloseFunction(line, document)
+    edit.insert(document.uri, new vscode.Position(lineCloseFunc.lineNumber, 0), template);
+
+    vscode.workspace.applyEdit(edit)
+}

package/src/provider/codeAction/controller/codeAction.ts

@@ -0,0 +1,34 @@
+import * as vscode from 'vscode';
+import { addPathParams } from './addPathParams';
+import { addTokenParam } from './addTokenParam';
+import { addValidationRequired } from './addValidation';
+
+
+export class ControllerActionProvider implements vscode.CodeActionProvider {
+
+    public static readonly providedCodeActionKinds = [
+        vscode.CodeActionKind.QuickFix
+    ];
+
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        range: any,
+    ): vscode.CodeAction[] | any {
+        const actionAddPathParams = addPathParams(document, range)
+        if (actionAddPathParams) {
+            return [actionAddPathParams]
+        }
+
+        const actionAddTokenParam = addTokenParam(document, range)
+        if (actionAddTokenParam) {
+            return [actionAddTokenParam]
+        }
+
+        const actionAddValidation = addValidationRequired(document, range)
+        if (actionAddValidation) {
+            return [actionAddValidation]
+        }
+
+        return []
+    }
+}

package/src/provider/codeAction/controller/util.ts

@@ -0,0 +1,48 @@
+import * as vscode from 'vscode';
+import { getMatch } from '../../../util';
+
+export function getLineCloseFunction(line: vscode.TextLine, document: vscode.TextDocument) {
+    const totalLine = document.lineCount
+
+    for (let index = line.lineNumber; index < totalLine; index++) {
+        const line = document.lineAt(index)
+
+        if (line.text.includes(') {') || line.text.includes('){')) return line
+    }
+
+    return line
+}
+
+export function getLineOpenFunction(line: vscode.TextLine, document: vscode.TextDocument) {
+    const totalLine = document.lineCount
+
+    for (let index = line.lineNumber; index < totalLine; index++) {
+        const line = document.lineAt(index)
+
+        if (line.text.includes('async') && line.text.includes('(')) return line
+    }
+
+    return line
+}
+
+export function getPathParams(path: string) {
+    const parts = path.split('/').filter(Boolean)
+
+    const params: any[] = []
+    parts.map(p => {
+        if (p.includes(':')) {
+            params.push(p.replace(':', ""))
+        }
+    })
+
+    return params
+}
+
+export function getPath(line: string) {
+    const paths = getMatch(/".*"|'.*'|`.*`/gm, line)
+    if (!paths || !paths.length) {
+        return ''
+    }
+
+    return paths[0].replace(/"/g, '').replace(/'/g, '').replace(/`/g, '')
+}