bmd-extension 1.6.3

package/src/provider/treeDataProvider/service/command/createService.ts

@@ -0,0 +1,70 @@
+import { FSProvider } from "../../../../FsProvider"
+import * as vscode from 'vscode';
+import { getFullTextType, getLastFolderFromPath, words, toSnakeCase, toUpperCaseFirstLetter } from "../../../../util";
+import { Confirmation, OTHER } from "../../../../constant";
+import { Uri, commands } from "vscode";
+
+export async function createService(fsPath: string) {
+    if (!FSProvider.isValidStructure()) {
+        return vscode.window.showInformationMessage("Cancel!. Wrong project's structure.");
+    }
+
+    if (fsPath != undefined && !fsPath.includes('services')) {
+        return vscode.window.showInformationMessage("Please select 'services' folder")
+    }
+
+    const entities = FSProvider.getAllFileInFolder('/src/entity')
+    const entitySelected = await vscode.window.showQuickPick(
+        [...entities, OTHER],
+        { ignoreFocusOut: true }
+    )
+    let service = ''
+    if (entitySelected && entitySelected != OTHER) {
+        service = entitySelected
+    } else {
+        let input = await vscode.window.showInputBox({
+            placeHolder: "Enter service name: ",
+            ignoreFocusOut: true
+        })
+        if (!input)
+            return vscode.window.showInformationMessage("Cancel!. Do not input service name.");
+
+        service = input.replace('service', '').replace('Service', '')
+    }
+
+    if (!service) {
+        return vscode.window.showInformationMessage("Cancel!. Do not input service name.");
+    }
+
+    const serviceTextTypes = getFullTextType(service)
+
+    const distPath = `src/services/${serviceTextTypes.classifyCase}Service.ts`
+    if (FSProvider.checkExist(distPath)) {
+        const confirm = await vscode.window.showQuickPick(
+            [Confirmation.Yes, Confirmation.No],
+            {
+                placeHolder: "This file already exist in this folder. Do you want to replace it?",
+                ignoreFocusOut: true
+            }
+        )
+        if (!confirm || confirm == Confirmation.No) {
+            return vscode.window.showInformationMessage("Cancel create service!.");
+        }
+    }
+
+    FSProvider.copyAndReplaceFile(
+        'service/service.txt',
+        distPath,
+        [
+            { regex: /{{snake}}/g, value: serviceTextTypes.snakeCase },
+            { regex: /{{classify}}/g, value: serviceTextTypes.classifyCase },
+            { regex: /{{camel}}/g, value: serviceTextTypes.camelCase },
+            { regex: /ys/g, value: 'ies' },
+        ])
+
+
+    let uri = Uri.file(FSProvider.getFullPath(distPath))
+    await commands.executeCommand('vscode.openFolder', uri)
+
+    return vscode.window.showInformationMessage("Create SERVICE successfully!");
+}

package/src/provider/treeDataProvider/service/command/handleConstructor.ts

@@ -0,0 +1,134 @@
+import * as vscode from 'vscode';
+import { getFullTextType } from '../../../../util';
+import { FSProvider } from '../../../../FsProvider';
+import { ConstructorFunction } from '../../../../constant';
+
+export async function insertPrivateService(typeFunc: ConstructorFunction, document: any) {
+
+    if (!document || !document.uri) {
+        document = vscode.window.activeTextEditor?.document
+    }
+
+    if (!document) {
+        vscode.window.showInformationMessage("Cancel: Can not find open document to insert")
+        return
+    }
+
+    const edit = new vscode.WorkspaceEdit();
+    const services = FSProvider.getAllFileInFolder('/src/services')
+    const service = await vscode.window.showQuickPick(
+        [...services], { ignoreFocusOut: true }
+    )
+    if (!service) return vscode.window.showInformationMessage('Please select service to complete action')
+    const fullTextService = getFullTextType(service)
+    const content = `\n\t\tprivate ${fullTextService.camelCase}: ${service},`
+
+    await insertConstructIfNotExist(document)
+
+    for (let index = 0; index < document.lineCount; index++) {
+        const line = document.lineAt(index).text
+        if (line.includes('constructor')) {
+            const matched1 = 'constructor()'
+            const matched2 = 'constructor('
+
+            if (line.indexOf(matched1) != -1) {
+                const indexOf = line.indexOf(matched1) + matched1.length
+                edit.insert(document.uri, new vscode.Position(index, indexOf - 1), content + `\n`);
+            } else {
+                const indexOf = line.indexOf(matched2) + matched2.length
+                edit.insert(document.uri, new vscode.Position(index, indexOf), content);
+            }
+        }
+    }
+
+    vscode.workspace.applyEdit(edit)
+}
+
+async function insertConstructIfNotExist(document: vscode.TextDocument) {
+    if (isExistConstructor(document)) return
+    const content = `    constructor(
+    ) { }\n`
+    const index = getIndexOfLineIncludeClass(document)
+    const edit = new vscode.WorkspaceEdit();
+    edit.insert(document.uri, new vscode.Position(index + 1, 0), content);
+    await vscode.workspace.applyEdit(edit)
+}
+
+function getIndexOfLineIncludeClass(document: vscode.TextDocument) {
+    const lines = document.lineCount
+    let indexLine = 0
+
+    for (let index = 0; index < lines; index++) {
+        const line = document.lineAt(index)
+        if (line.text.includes('class')) {
+            indexLine = index
+            break;
+        }
+    }
+    return indexLine
+}
+
+function isExistConstructor(document: vscode.TextDocument) {
+    const lines = document.lineCount
+    let isExist = false
+
+    for (let index = 0; index < lines; index++) {
+        const line = document.lineAt(index)
+        if (line.text.includes('constructor')) {
+            isExist = true
+        }
+    }
+    return isExist
+}
+
+// export function insertConstructorAction(
+//     document: vscode.TextDocument | undefined,
+//     range: any,
+// ) {
+//     if (!document || !document.uri) {
+//         document = vscode.window.activeTextEditor?.document
+//     }
+
+//     if (!document) {
+//         vscode.window.showInformationMessage("Cancel: Can not find open document to insert")
+//         return
+//     }
+
+//     if (isConstructorFunction(document, range)) {
+//         const insertPrivateService = createConstructorFunc(document, range, ConstructorFunction.PrivateService);
+
+//         return [
+//             insertPrivateService
+//         ]
+//     } else {
+//         return []
+//     }
+// }
+
+// function isConstructorFunction(document: vscode.TextDocument, range: vscode.Range) {
+//     const start = range.start;
+//     const line = document.lineAt(start.line);
+//     return line.text.includes('constructor')
+// }
+
+
+// function createConstructorFunc(document: vscode.TextDocument, range: vscode.Range, typeFunc: ConstructorFunction): vscode.CodeAction {
+//     const controller = new vscode.CodeAction(typeFunc, vscode.CodeActionKind.QuickFix);
+//     switch (typeFunc) {
+//         case ConstructorFunction.PrivateService:
+//             controller.command = {
+//                 command: typeFunc,
+//                 title: 'Insert private service.',
+//                 tooltip: 'Insert private service.',
+//                 arguments: [document]
+//             };
+//             break
+
+
+//         default:
+//             break;
+
+//     }
+
+//     return controller;
+// }

package/src/provider/treeDataProvider/service/treeData.ts

@@ -0,0 +1,25 @@
+import { BMDCommand, ConstructorFunction } from "../../../constant";
+import { Dependency } from "../Dependency";
+import * as vscode from 'vscode';
+import { ItemCommand } from "../TreeProviderCommand";
+
+const serviceCommands: ItemCommand[] =
+    [{
+        id: BMDCommand.CreateService,
+        title: 'SERVICE',
+        icon: 'add'
+    }, {
+        id: ConstructorFunction.PrivateService,
+        title: 'INJECT CONSTRUCTOR',
+        icon: 'vaccine'
+    },]
+
+export const serviceDependencies = serviceCommands.map(c => {
+    return new Dependency(
+        c.title,
+        vscode.TreeItemCollapsibleState.None,
+        undefined,
+        c.id,
+        c.icon ? c.icon : 'none'
+    );
+})

package/src/types/project.d.ts

@@ -0,0 +1,7 @@
+
+
+export interface Project {
+    name: string;
+    stagingUrl: string
+    productionUrl: string;
+}

package/src/util.ts

@@ -0,0 +1,145 @@
+export function replaceSymbolTemplate(content: string) {
+    content = content.replace(/{{backtick}}/g, '`');
+    content = content.replace(/{{dollar}}/g, '$');
+    return content
+}
+
+export function toLowerCaseFirstLetter(name: string) {
+    return name.charAt(0).toLowerCase() + name.slice(1)
+}
+
+export function toUpperCaseFirstLetter(name: string) {
+    return name.charAt(0).toUpperCase() + name.slice(1)
+}
+
+interface TextType {
+    lowerCase: string,
+    upperCase: string,
+    camelCase: string,
+    kebabCase: string,
+    titleCase: string,
+    snakeCase: string,
+    snakeUpperCase: string,
+    classifyCase: string
+}
+
+export function getFullTextType(text: string): TextType {
+    return {
+        lowerCase: text.toLowerCase(),
+        upperCase: text.toUpperCase(),
+        camelCase: toCamelCase(text),
+        kebabCase: toKebabCase(text),
+        titleCase: toTitleCase(text),
+        snakeCase: toSnakeCase(text),
+        snakeUpperCase: toSnakeUpperCase(text),
+        classifyCase: capitalize(text)
+    }
+}
+
+export const words = (str: any, pattern = /[^a-zA-Z-]+/): string[] => str.split(pattern).filter(Boolean);
+
+export const toCamelCase = (str: any) => {
+    let s =
+        str &&
+        str
+            .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+            .map((x: any) => {
+                return x.slice(0, 1).toUpperCase() + x.slice(1).toLowerCase();
+            })
+            .join('');
+    return s.slice(0, 1).toLowerCase() + s.slice(1);
+};
+
+export const toKebabCase = (str: any) =>
+    str &&
+    str
+        .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+        .map((x: any) => x.toLowerCase())
+        .join('-');
+
+export const toTitleCase = (str: any) =>
+    str
+        .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+        .map((x: any) => x.charAt(0).toUpperCase() + x.slice(1))
+        .join(' ');
+
+export const capitalize = ([first, ...rest]: string, lowerRest = false) => {
+    return first.toUpperCase() + (lowerRest ? rest.join('').toLowerCase() : rest.join(''));
+};
+
+export const toSnakeCase = (str: any) => {
+    return str &&
+        str
+            .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+            .map((x: any) => x.toLowerCase())
+            .join('_');
+}
+
+export const toSnakeUpperCase = (str: any) => {
+    return str &&
+        str
+            .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+            .map((x: any) => x.toUpperCase())
+            .join('_');
+}
+
+export function getLastFolderFromPath(path: string): string {
+    if (!path) return ''
+    const folders = path.split('/')
+    return folders[folders.length - 1]
+}
+
+export function getWordBetweenSpace(line: string, indexSelected: number) {
+    const symbolBreakWork = [' ', '`', "'", '.', '(', ')']
+    let isBreakByDot = false
+
+    let text = ''
+    let lastIndex = indexSelected - 1
+    for (let index = indexSelected - 1; index > 0; index--) {
+        const char = line[index];
+        if (!symbolBreakWork.includes(char)) {
+            text = char + text
+        } else {
+            if (char == '.') isBreakByDot = true
+            break
+        }
+    }
+
+    for (let index = indexSelected; index < line.length; index++) {
+        const char = line[index]
+        if (!symbolBreakWork.includes(char)) {
+            text += char
+            lastIndex = index
+        } else {
+            break
+        }
+    }
+
+    return { text, lastIndex, isBreakByDot }
+}
+
+export function removePlural(name: string) {
+    name = name.replace(/ies$/, 'y')
+    name = name.replace(/ses$/, 's')
+    name = name.replace(/s$/, '')
+    return name
+}
+
+export function getMatch(regex: any, str: string) {
+    let m;
+
+    const matches: string[] = []
+    while ((m = regex.exec(str)) !== null) {
+        // This is necessary to avoid infinite loops with zero-width matches
+        if (m.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
+
+        // The result can be accessed through the `m`-variable.
+        m.forEach((match: string, groupIndex: number) => {
+            matches.push(match)
+        });
+    }
+
+    return matches
+}

package/src/utils/Password.ts

@@ -0,0 +1,19 @@
+import * as vscode from 'vscode';
+
+
+export class Password {
+
+    static getProjectPassword() {
+        const config = vscode.workspace.getConfiguration("bmdextension")
+        const password = config.projectPassword;
+
+        return password;
+    }
+
+    static getApiPassword() {
+        const config = vscode.workspace.getConfiguration("bmdextension")
+        const password = config.apiPassword;
+
+        return password;
+    }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es6",
+    "skipDefaultLibCheck": true,
+    "skipLibCheck": true,
+    "outDir": "out",
+    "lib": ["es6"],
+    "sourceMap": true,
+    "rootDir": "src",
+    "strict": true /* enable all strict type-checking options */
+    /* Additional Checks */
+    // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
+    // "noUnusedParameters": true,  /* Report errors on unused parameters. */
+  },
+  "exclude": ["node_modules", ".vscode-test", "**/assets/**"]
+}

package/tslint.json

@@ -0,0 +1,15 @@
+{
+	"rules": {
+		"no-string-throw": true,
+		"no-unused-expression": true,
+		"no-duplicate-variable": true,
+		"curly": true,
+		"class-name": true,
+		"semicolon": [
+			true,
+			"always"
+		],
+		"triple-equals": true
+	},
+	"defaultSeverity": "warning"
+}

package/vsc-extension-quickstart.md

@@ -0,0 +1,42 @@
+# Welcome to your VS Code Extension
+
+## What's in the folder
+
+* This folder contains all of the files necessary for your extension.
+* `package.json` - this is the manifest file in which you declare your extension and command.
+  * The sample plugin registers a command and defines its title and command name. With this information VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
+* `src/extension.ts` - this is the main file where you will provide the implementation of your command.
+  * The file exports one function, `activate`, which is called the very first time your extension is activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
+  * We pass the function containing the implementation of the command as the second parameter to `registerCommand`.
+
+## Get up and running straight away
+
+* Press `F5` to open a new window with your extension loaded.
+* Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
+* Set breakpoints in your code inside `src/extension.ts` to debug your extension.
+* Find output from your extension in the debug console.
+
+## Make changes
+
+* You can relaunch the extension from the debug toolbar after changing code in `src/extension.ts`.
+* You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
+
+
+## Explore the API
+
+* You can open the full set of our API when you open the file `node_modules/@types/vscode/index.d.ts`.
+
+## Run tests
+
+* Open the debug viewlet (`Ctrl+Shift+D` or `Cmd+Shift+D` on Mac) and from the launch configuration dropdown pick `Extension Tests`.
+* Press `F5` to run the tests in a new window with your extension loaded.
+* See the output of the test result in the debug console.
+* Make changes to `src/test/suite/extension.test.ts` or create new test files inside the `test/suite` folder.
+  * The provided test runner will only consider files matching the name pattern `**.test.ts`.
+  * You can create folders inside the `test` folder to structure your tests any way you want.
+
+## Go further
+
+ * Reduce the extension size and improve the startup time by [bundling your extension](https://code.visualstudio.com/api/working-with-extensions/bundling-extension).
+ * [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VSCode extension marketplace.
+ * Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).