tnp-helpers 19.0.5 → 19.0.7

package/lib/utils.js

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilsQuickFixes = exports.UtilsMd = exports.UtilsHttp = exports.UtilsTypescript = exports.UtilsNpm = void 0;
 //#region imports
-const tnp_core_1 = require("tnp-core");
-const tnp_core_2 = require("tnp-core");
+const lib_1 = require("tnp-core/lib");
+const lib_2 = require("tnp-core/lib");
 const typescript_1 = require("typescript");
+const index_1 = require("./index");
 //#endregion
 //#region utils npm
 var UtilsNpm;
 (function (UtilsNpm) {
     //#region is special version
     UtilsNpm.isSpecialVersion = (version) => {
-        return tnp_core_2.CoreModels.NpmSpecialVersions.includes(version);
+        return lib_2.CoreModels.NpmSpecialVersions.includes(version);
     };
     //#endregion
     //#region clear version
@@ -22,7 +23,7 @@ var UtilsNpm;
         }
         version = (version || '')
             .trim()
-            .replace(new RegExp(tnp_core_2.Utils.escapeStringForRegEx('undefined'), 'g'), '0');
+            .replace(new RegExp(lib_2.Utils.escapeStringForRegEx('undefined'), 'g'), '0');
         if (removePrefixes) {
             version = version.replace('^', '').replace('~', '');
         }
@@ -40,7 +41,7 @@ var UtilsNpm;
         }
         version = (version || '')
             .trim()
-            .replace(new RegExp(tnp_core_2.Utils.escapeStringForRegEx('undefined'), 'g'), '0');
+            .replace(new RegExp(lib_2.Utils.escapeStringForRegEx('undefined'), 'g'), '0');
         const splited = version.split('.');
         let [major, minor, patch, alphaOrBetaOrRc] = splited;
         if (splited.length === 1) {
@@ -170,7 +171,7 @@ var UtilsTypescript;
         if (!filePath.endsWith('.ts')) {
             return [];
         }
-        const file = tnp_core_1.Helpers.readFile(filePath);
+        const file = index_1.Helpers.readFile(filePath);
         return UtilsTypescript.exportsFromContent(file);
         //#endregion
     };
@@ -271,13 +272,13 @@ var UtilsTypescript;
         if (!absoluteFilePath.endsWith('.ts')) {
             return [];
         }
-        const sourceCode = tnp_core_1.Helpers.readFile(absoluteFilePath);
+        const sourceCode = index_1.Helpers.readFile(absoluteFilePath);
         return UtilsTypescript.extractClassNameFromString(sourceCode);
         //#endregion
     };
     UtilsTypescript.extractDefaultClassNameFromFile = (absoluteFilePath) => {
         //#region @backendFunc
-        const sourceCode = tnp_core_1.Helpers.readFile(absoluteFilePath);
+        const sourceCode = index_1.Helpers.readFile(absoluteFilePath);
         return UtilsTypescript.extractDefaultClassNameFromString(sourceCode);
         //#endregion
     };
@@ -285,31 +286,73 @@ var UtilsTypescript;
     //#region format file(s) with prettier
     UtilsTypescript.formatFile = (absPathToFile) => {
         //#region @backendFunc
-        if (tnp_core_1.Helpers.exists(absPathToFile)) {
+        if (index_1.Helpers.exists(absPathToFile)) {
             const { execSync } = require('child_process');
-            tnp_core_1.Helpers.logInfo(`Formatting file: ${absPathToFile}`);
+            index_1.Helpers.logInfo(`Formatting file: ${absPathToFile}`);
             try {
-                execSync(`prettier --write ${tnp_core_1.path.basename(absPathToFile)}`, {
-                    cwd: tnp_core_1.path.dirname(absPathToFile),
+                execSync(`prettier --write ${lib_1.path.basename(absPathToFile)}`, {
+                    cwd: lib_1.path.dirname(absPathToFile),
                 });
             }
             catch (error) {
                 console.warn(`Not able to format file: ${absPathToFile}`);
             }
-            tnp_core_1.Helpers.taskDone(`Formatting file done.`);
+            index_1.Helpers.taskDone(`Formatting file done.`);
         }
         //#endregion
     };
     UtilsTypescript.formatAllFilesInsideFolder = (absPathToFolder) => {
         //#region @backendFunc
-        if (tnp_core_1.Helpers.exists(absPathToFolder)) {
+        if (index_1.Helpers.exists(absPathToFolder)) {
+            if (!index_1.Helpers.isFolder(absPathToFolder)) {
+                index_1.Helpers.error(`"${absPathToFolder}" is not a folder`);
+            }
             const { execSync } = require('child_process');
             try {
                 execSync(`prettier --write .`, { cwd: absPathToFolder });
             }
             catch (error) {
-                console.warn(`Not able to files in: ${absPathToFolder}`);
+                console.warn(`Not able to prettier all files in: ${absPathToFolder}`);
+            }
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region lint file(s) with eslint
+    UtilsTypescript.eslintFixFile = (absPathToFile) => {
+        //#region @backendFunc
+        absPathToFile = (0, lib_1.crossPlatformPath)(absPathToFile);
+        if (index_1.Helpers.exists(absPathToFile)) {
+            const { execSync } = require('child_process');
+            index_1.Helpers.logInfo(`Fixing file with eslint: ${absPathToFile}`);
+            try {
+                execSync(`npx --yes eslint --fix ${lib_1.path.basename(absPathToFile)}`, {
+                    cwd: lib_1.path.dirname(absPathToFile),
+                });
             }
+            catch (error) { }
+            index_1.Helpers.taskDone(`Eslint file fix done.`);
+        }
+        //#endregion
+    };
+    UtilsTypescript.eslintFixAllFilesInsideFolder = (absPathToFolder) => {
+        //#region @backendFunc
+        absPathToFolder = (0, lib_1.crossPlatformPath)(absPathToFolder);
+        if (index_1.Helpers.exists(absPathToFolder)) {
+            index_1.Helpers.info(`Fixing files with eslint in: ${absPathToFolder}`);
+            const lintFixFn = () => {
+                try {
+                    index_1.Helpers.run(`npx --yes eslint --fix . `, {
+                        cwd: absPathToFolder,
+                        output: false,
+                        silence: true,
+                    }).sync();
+                }
+                catch (error) { }
+            };
+            lintFixFn();
+            lintFixFn(); // sometimes it needs to be run twice
+            index_1.Helpers.info(`Eslint fixing files done.`);
         }
         //#endregion
     };
@@ -359,14 +402,14 @@ var UtilsTypescript;
     };
     UtilsTypescript.getTaonContextsNamesFromFile = (tsAbsFilePath) => {
         //#region @backendFunc
-        return UtilsTypescript.getTaonContextFromContent(tnp_core_1.Helpers.readFile(tsAbsFilePath));
+        return UtilsTypescript.getTaonContextFromContent(index_1.Helpers.readFile(tsAbsFilePath));
         //#endregion
     };
     //#endregion
     //#region extract selectors from Angular components class files
     UtilsTypescript.extractAngularComponentSelectors = (fileAbsPath) => {
         //#region @backendFunc
-        const sourceFile = (0, typescript_1.createSourceFile)(fileAbsPath, tnp_core_1.Helpers.readFile(fileAbsPath), typescript_1.ScriptTarget.Latest, true);
+        const sourceFile = (0, typescript_1.createSourceFile)(fileAbsPath, index_1.Helpers.readFile(fileAbsPath), typescript_1.ScriptTarget.Latest, true);
         const selectors = [];
         const visit = (node) => {
             if ((0, typescript_1.isClassDeclaration)(node) && node.name) {
@@ -406,7 +449,7 @@ var UtilsTypescript;
     //#region wrap one line with comment
     UtilsTypescript.wrapWithComment = (oneLineComment, absDestFilePath) => {
         //#region @backendFunc
-        const ext = tnp_core_1.path.extname(absDestFilePath).toLowerCase();
+        const ext = lib_1.path.extname(absDestFilePath).toLowerCase();
         let commentSyntax;
         switch (ext) {
             case '.ts':
@@ -445,7 +488,7 @@ var UtilsTypescript;
      */
     UtilsTypescript.setValueToVariableInTsFile = (tsAbsFilePath, variableName, valueOfVariable, addIfNotExists = true) => {
         //#region @backendFunc
-        const sourceText = tnp_core_1.Helpers.readFile(tsAbsFilePath);
+        const sourceText = index_1.Helpers.readFile(tsAbsFilePath);
         const sourceFile = (0, typescript_1.createSourceFile)(tsAbsFilePath, sourceText, typescript_1.ScriptTarget.Latest, 
         /*setParentNodes */ true);
         // We'll build an AST transformer that modifies or inserts our variable declaration
@@ -519,7 +562,7 @@ var UtilsTypescript;
         const printer = (0, typescript_1.createPrinter)();
         const newContent = printer.printFile(transformedSourceFile);
         // Overwrite the file
-        tnp_core_1.Helpers.writeFile(tsAbsFilePath, newContent);
+        index_1.Helpers.writeFile(tsAbsFilePath, newContent);
         result.dispose();
         //#endregion
     };
@@ -527,31 +570,61 @@ var UtilsTypescript;
     //#region recognize imports from file
     //#region helpers / ts import export class
     class TsImportExport {
+        /**
+         * for external modification
+         */
+        embeddedPathToFileResult;
+        /**
+         * for external modification
+         */
+        packageName;
+        /**
+         * for external modification
+         */
+        isIsomorphic;
+        //#region generated/readonly files
         type;
         /**
          * ORIGNAL
          * Name of the file that is being imported/exported
-         * with parenthesis included
+         * with parenthesis included , example
+         * 'my-file' or "my-file" or `my-file`
          */
         embeddedPathToFile;
         /**
-         * same as cleanEmbeddedPathToFile but without quotes (parenthesis)
+         * same as cleanEmbeddedPathToFile but without quotes (parenthesis), example:
+         * my-file or my-file or my-file
          */
         cleanEmbeddedPathToFile;
+        startRow;
+        startCol;
+        endRow;
+        endCol;
+        parenthesisType;
+        importElements = [];
+        //#endregion
+        //#region constructor
+        constructor(type, embeddedPathToFile, start, end, parenthesisType, importElements = []) {
+            this.type = type;
+            this.isIsomorphic = false;
+            this.embeddedPathToFile = embeddedPathToFile;
+            this.cleanEmbeddedPathToFile =
+                this.removeStartEndQuotes(embeddedPathToFile);
+            this.embeddedPathToFileResult = embeddedPathToFile;
+            this.startRow = start.line + 1; // TypeScript lines are zero-based
+            this.startCol = start.character + 1;
+            this.endRow = end.line + 1;
+            this.endCol = end.character + 1;
+            this.parenthesisType = parenthesisType;
+            this.importElements = importElements;
+        }
+        //#endregion
+        //#region remove quotes
         removeStartEndQuotes(str) {
             return str.replace(/^['"`]/, '').replace(/['"`]$/, '');
         }
-        /**
-         * RESULT OF PROCESSING
-         */
-        embeddedPathToFileResult;
-        /**
-         * @deprecated use cleanEmbeddedPathToFile
-         */
-        packageName;
-        isIsomorphic;
-        startRow;
-        startCol;
+        //#endregion
+        //#region get string part
         /**
          * it will extract part of the file content
          * that is between startRow, startCol and endRow, endCol
@@ -588,30 +661,15 @@ var UtilsTypescript;
             }
             return extractedLines.join('\n');
         }
-        endRow;
-        endCol;
-        parenthesisType;
+        //#endregion
+        //#region wrap in current parenthesis
         wrapInParenthesis(str) {
             return this.parenthesisType === 'single'
                 ? `'${str}'`
                 : this.parenthesisType === 'double'
                     ? `"${str}"`
                     : `\`${str}\``;
-        }
-        importElements = [];
-        constructor(type, embeddedPathToFile, start, end, parenthesisType, importElements = []) {
-            this.type = type;
-            this.isIsomorphic = false;
-            this.embeddedPathToFile = embeddedPathToFile;
-            this.cleanEmbeddedPathToFile =
-                this.removeStartEndQuotes(embeddedPathToFile);
-            this.embeddedPathToFileResult = embeddedPathToFile;
-            this.startRow = start.line + 1; // TypeScript lines are zero-based
-            this.startCol = start.character + 1;
-            this.endRow = end.line + 1;
-            this.endCol = end.character + 1;
-            this.parenthesisType = parenthesisType;
-            this.importElements = importElements;
+            //#endregion
         }
     }
     UtilsTypescript.TsImportExport = TsImportExport;
@@ -644,7 +702,7 @@ var UtilsTypescript;
     };
     UtilsTypescript.recognizeImportsFromFile = (fileAbsPAth) => {
         //#region @backendFunc
-        const content = tnp_core_1.Helpers.readFile(fileAbsPAth);
+        const content = index_1.Helpers.readFile(fileAbsPAth);
         return UtilsTypescript.recognizeImportsFromContent(content);
         //#endregion
     };
@@ -694,6 +752,234 @@ var UtilsTypescript;
         //#endregion
     };
     //#endregion
+    //#region fix standalone ng 19
+    /**
+     * Transition methods ng18 => ng19
+     * Remove standalone:true from component decorator
+     * and add standalone: false if not exists
+     */
+    function transformComponentStandaloneOption(sourceText) {
+        //#region @backendFunc
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceText, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
+        const printer = (0, typescript_1.createPrinter)({ newLine: typescript_1.NewLineKind.LineFeed });
+        // @ts-ignore
+        const transformerFactory = context => {
+            const { factory } = context;
+            const visit = node => {
+                if ((0, typescript_1.isDecorator)(node) &&
+                    (0, typescript_1.isCallExpression)(node.expression) &&
+                    (0, typescript_1.isIdentifier)(node.expression.expression) &&
+                    node.expression.expression.text === 'Component') {
+                    const args = node.expression.arguments;
+                    if (args.length === 1 && (0, typescript_1.isObjectLiteralExpression)(args[0])) {
+                        const originalProps = args[0].properties;
+                        const newProps = [];
+                        let hasStandalone = false;
+                        let standaloneIsTrue = false;
+                        for (const prop of originalProps) {
+                            if ((0, typescript_1.isPropertyAssignment)(prop) &&
+                                (0, typescript_1.isIdentifier)(prop.name) &&
+                                prop.name.text === 'standalone') {
+                                hasStandalone = true;
+                                if (prop.initializer.kind === typescript_1.SyntaxKind.TrueKeyword) {
+                                    standaloneIsTrue = true;
+                                    continue; // skip it
+                                }
+                            }
+                            newProps.push(prop);
+                        }
+                        if (!hasStandalone) {
+                            // add standalone: false
+                            newProps.push(factory.createPropertyAssignment(factory.createIdentifier('standalone'), factory.createFalse()));
+                        }
+                        const newArgs = [
+                            factory.updateObjectLiteralExpression(args[0], newProps),
+                        ];
+                        const newExpression = factory.updateCallExpression(node.expression, node.expression.expression, undefined, newArgs);
+                        return factory.updateDecorator(node, newExpression);
+                    }
+                }
+                return (0, typescript_1.visitEachChild)(node, visit, context);
+            };
+            return node => (0, typescript_1.visitNode)(node, visit);
+        };
+        const result = (0, typescript_1.transform)(sourceFile, [transformerFactory]);
+        const transformedSourceFile = result.transformed[0];
+        const resultText = printer.printFile(transformedSourceFile);
+        result.dispose();
+        return resultText;
+        //#endregion
+    }
+    UtilsTypescript.transformComponentStandaloneOption = transformComponentStandaloneOption;
+    //#endregion
+    //#region escape @ in html text
+    const escapeAtInHtmlText = (fileContent) => {
+        return fileContent.replace(/>([^<@]*?)@([^<]*)</g, (_match, before, after) => {
+            return `>${before}&#64;${after}<`;
+        });
+    };
+    UtilsTypescript.fixHtmlTemplatesInDir = (directoryPath) => {
+        //#region @backendFunc
+        index_1.Helpers.taskStarted(`(before prettier) Fixing HTML templates in`);
+        const files = index_1.Helpers.filesFrom(directoryPath, true, false);
+        for (const fullPath of files) {
+            const file = lib_1.path.basename(fullPath);
+            if (index_1.Helpers.exists(fullPath)) {
+                const stat = lib_1.fse.statSync(fullPath);
+                if (file.endsWith('.html')) {
+                    const original = index_1.Helpers.readFile(fullPath);
+                    const fixed = escapeAtInHtmlText(original);
+                    if (fixed !== original) {
+                        index_1.Helpers.writeFile(fullPath, fixed);
+                        console.log(`Html fixed @ -> &#64: ${fullPath}`);
+                    }
+                }
+            }
+        }
+        index_1.Helpers.taskDone(`(before prettier) Fixing HTML templates done.`);
+        //#endregion
+    };
+    //#endregion
+    //#region remove tagged imports/exports
+    function removeTaggedImportExport(tsFileContent, tags) {
+        //#region @backendFunc
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', tsFileContent, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
+        // debug && console.log(tsFileContent);
+        const lines = tsFileContent.split(/\r?\n/);
+        const tagRegex = new RegExp(tags
+            .map(t => (Array.isArray(t) ? t[0] : t))
+            .filter(Boolean)
+            .map(lib_2.Utils.escapeStringForRegEx)
+            .join('|'), 'i');
+        let a = 0;
+        for (const statement of sourceFile.statements) {
+            // debug && console.log('processing line ' + a++);
+            if (!(0, typescript_1.isImportDeclaration)(statement) && !(0, typescript_1.isExportDeclaration)(statement)) {
+                continue;
+            }
+            const start = statement.getStart();
+            const end = statement.getEnd();
+            const startLine = sourceFile.getLineAndCharacterOfPosition(start).line;
+            const endLine = sourceFile.getLineAndCharacterOfPosition(end).line;
+            // get full text including trailing comments
+            const endLineText = lines[endLine]; // ← get real line content from file
+            if (!tagRegex.test(endLineText))
+                continue;
+            // debug &&
+            //   console.log(`
+            //   start: ${start}
+            //   end: ${end}
+            //   startLine: ${startLine}
+            //   endLine: ${endLine}
+            //   endLineText: >> ${endLineText} <<
+            //   `);
+            // console.log('removing line ' + startLine + ' to ' + endLine);
+            for (let i = startLine; i <= endLine; i++) {
+                const original = lines[i];
+                lines[i] = '/* */' + ' '.repeat(Math.max(0, original.length - 4));
+            }
+        }
+        // debug && console.log('\n\n\n\n');
+        const result = lines.join('\n');
+        // debug && console.log(result)
+        return result;
+        //#endregion
+    }
+    UtilsTypescript.removeTaggedImportExport = removeTaggedImportExport;
+    //#endregion
+    //#region wrap first imports in region
+    UtilsTypescript.wrapFirstImportsInImportsRegion = (fileContent) => {
+        //#region @backendFunc
+        const importRegionStart = `//#re` + `gion imports`;
+        const importRegionEnd = `//#end` + `region`;
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', fileContent, typescript_1.ScriptTarget.Latest, true);
+        const lines = fileContent.split(/\r?\n/);
+        const importDeclarations = [];
+        for (const statement of sourceFile.statements) {
+            if ((0, typescript_1.isImportDeclaration)(statement)) {
+                importDeclarations.push(statement);
+            }
+            else if ((0, typescript_1.isEmptyStatement)(statement) ||
+                ((0, typescript_1.isExpressionStatement)(statement) &&
+                    statement.getFullText(sourceFile).trim() === '')) {
+                // skip empty lines or empty statements
+                continue;
+            }
+            else {
+                break; // stop at first non-import statement
+            }
+        }
+        if (importDeclarations.length === 0) {
+            return fileContent; // nothing to wrap
+        }
+        const firstImportStart = importDeclarations[0].getFullStart();
+        const lastImportEnd = importDeclarations[importDeclarations.length - 1].getEnd();
+        // Get the line numbers (1-based)
+        const startLine = sourceFile.getLineAndCharacterOfPosition(firstImportStart).line;
+        const endLine = sourceFile.getLineAndCharacterOfPosition(lastImportEnd).line;
+        const before = lines.slice(0, startLine);
+        const importBlock = lines.slice(startLine, endLine + 1);
+        const after = lines.slice(endLine + 1);
+        return [
+            ...before,
+            importRegionStart,
+            ...importBlock,
+            importRegionEnd,
+            ...after,
+        ].join('\n');
+        //#endregion
+    };
+    //#endregion
+    //#region wrap entities class fields with region
+    const applyEdits = (original, edits) => {
+        edits.sort((a, b) => b.pos - a.pos); // apply from end to start
+        let result = original;
+        for (const edit of edits) {
+            result = result.slice(0, edit.pos) + edit.text + result.slice(edit.pos);
+        }
+        return result;
+    };
+    /**
+     * wrap class field with decorators
+     * wrap class methods with decorators
+     */
+    function wrapContentClassMembersDecoratorsWithRegion(classFileContent, wrapTag = '@websql') {
+        //#region @backendFunc
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', classFileContent, typescript_1.ScriptTarget.Latest, true);
+        const edits = [];
+        const isAlreadyWrapped = (decorator) => {
+            const text = decorator.getFullText(sourceFile);
+            return (text.includes(`//#reg` + `ion ${wrapTag}`) ||
+                text.includes(`//#end` + `reg` + `ion`));
+        };
+        const visit = (node) => {
+            if ((0, typescript_1.isClassDeclaration)(node)) {
+                for (const member of node.members) {
+                    if (!(0, typescript_1.isPropertyDeclaration)(member) && !(0, typescript_1.isMethodDeclaration)(member))
+                        continue;
+                    const decorators = (0, typescript_1.canHaveDecorators)(member)
+                        ? (0, typescript_1.getDecorators)(member)
+                        : undefined;
+                    if (!decorators || decorators.length === 0)
+                        continue;
+                    for (const decorator of decorators) {
+                        if (isAlreadyWrapped(decorator))
+                            continue;
+                        const start = decorator.getStart();
+                        const end = decorator.getEnd();
+                        edits.push({ pos: start, text: `\n//#reg` + `ion ${wrapTag}\n` });
+                        edits.push({ pos: end, text: `\n//#end` + `reg` + `ion` }); // No extra newline
+                    }
+                }
+            }
+            (0, typescript_1.forEachChild)(node, visit);
+        };
+        visit(sourceFile);
+        return applyEdits(classFileContent, edits);
+        //#endregion
+    }
+    UtilsTypescript.wrapContentClassMembersDecoratorsWithRegion = wrapContentClassMembersDecoratorsWithRegion;
+    //#endregion
 })(UtilsTypescript || (exports.UtilsTypescript = UtilsTypescript = {}));
 //#endregion
 //#region utils http
@@ -831,9 +1117,9 @@ var UtilsQuickFixes;
     /**
      * for some reason electron is being bundled - and it is not needed for cli
      */
-    UtilsQuickFixes.replaceElectronWithNothing = (jsContent) => {
+    UtilsQuickFixes.replaceElectronWithNothing = (jsContent, packageName) => {
         //#region @backendFunc
-        return jsContent.replace(`mod${'ule.exports'} = ${'requ' + 'ire'}("electron");`, '');
+        return jsContent.replace(`mod${'ule.exports'} = ${'requ' + 'ire'}("${packageName}");`, '');
         //#endregion
     };
 })(UtilsQuickFixes || (exports.UtilsQuickFixes = UtilsQuickFixes = {}));