tnp-helpers 18.0.19 → 18.0.21

package/lib/utils.js

@@ -1,26 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilsQuickFixes = exports.UtilsMd = exports.UtilsHttp = exports.UtilsTypescript = exports.UtilsNpm = void 0;
-var tslib_1 = require("tslib");
 //#region imports
-//#region @backend
-var tnp_core_1 = require("tnp-core");
-var express = require("express");
-var typescript_1 = require("typescript");
-//#endregion
-var tnp_core_2 = require("tnp-core");
+const tnp_core_1 = require("tnp-core");
+const tnp_core_2 = require("tnp-core");
+const typescript_1 = require("typescript");
 //#endregion
 //#region utils npm
 var UtilsNpm;
 (function (UtilsNpm) {
     //#region is special version
-    UtilsNpm.isSpecialVersion = function (version) {
+    UtilsNpm.isSpecialVersion = (version) => {
         return tnp_core_2.CoreModels.NpmSpecialVersions.includes(version);
     };
     //#endregion
     //#region clear version
-    UtilsNpm.clearVersion = function (version, options) {
-        var _a = options || {}, removePrefixes = _a.removePrefixes, removeSuffix = _a.removeSuffix;
+    UtilsNpm.clearVersion = (version, options) => {
+        const { removePrefixes, removeSuffix } = options || {};
         if (!version || UtilsNpm.isSpecialVersion(version)) {
             return version;
         }
@@ -30,23 +26,23 @@ var UtilsNpm;
         if (removePrefixes) {
             version = version.replace('^', '').replace('~', '');
         }
-        var _b = tslib_1.__read(version.split('.'), 4), major = _b[0], minor = _b[1], patch = _b[2], alphaOrBetaOrRc = _b[3];
+        let [major, minor, patch, alphaOrBetaOrRc] = version.split('.');
         if (removeSuffix) {
             alphaOrBetaOrRc = '';
         }
-        return UtilsNpm.fixMajorVerNumber("".concat(major, ".").concat(minor, ".").concat(patch).concat(alphaOrBetaOrRc ? '.' + alphaOrBetaOrRc : ''));
+        return UtilsNpm.fixMajorVerNumber(`${major}.${minor}.${patch}${alphaOrBetaOrRc ? '.' + alphaOrBetaOrRc : ''}`);
     };
     //#endregion
     //#region fix major version number
-    UtilsNpm.fixMajorVerNumber = function (version) {
+    UtilsNpm.fixMajorVerNumber = (version) => {
         if (!version || UtilsNpm.isSpecialVersion(version)) {
             return version;
         }
         version = (version || '')
             .trim()
             .replace(new RegExp(tnp_core_2.Utils.escapeStringForRegEx('undefined'), 'g'), '0');
-        var splited = version.split('.');
-        var _a = tslib_1.__read(splited, 4), major = _a[0], minor = _a[1], patch = _a[2], alphaOrBetaOrRc = _a[3];
+        const splited = version.split('.');
+        let [major, minor, patch, alphaOrBetaOrRc] = splited;
         if (splited.length === 1) {
             minor = '0';
             patch = '0';
@@ -54,7 +50,7 @@ var UtilsNpm;
         else if (splited.length === 2) {
             patch = '0';
         }
-        return "".concat(major, ".").concat(minor, ".").concat(patch).concat(alphaOrBetaOrRc ? '.' + alphaOrBetaOrRc : '');
+        return `${major}.${minor}.${patch}${alphaOrBetaOrRc ? '.' + alphaOrBetaOrRc : ''}`;
     };
     //#endregion
 })(UtilsNpm || (exports.UtilsNpm = UtilsNpm = {}));
@@ -70,18 +66,18 @@ var UtilsTypescript;
      * @param regionName - The name of the region to remove.
      * @returns Modified TypeScript code without the specified regions.
      */
-    UtilsTypescript.removeRegionByName = function (sourceCode, regionName) {
+    UtilsTypescript.removeRegionByName = (sourceCode, regionName) => {
         //#region @backendFunc
         // Create a source file using TypeScript's compiler API
-        var sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceCode, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceCode, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
         // Prepare a printer to convert the modified AST back to code
-        var printer = (0, typescript_1.createPrinter)();
+        const printer = (0, typescript_1.createPrinter)();
         // Traverse the AST and remove specified //#region blocks
-        var transformer = function (context) {
-            var visit = function (node) {
+        const transformer = (context) => {
+            const visit = (node) => {
                 // @ts-ignore
                 if ((0, typescript_1.isSourceFile)(node)) {
-                    var statements = removeRegions(node.statements, regionName);
+                    const statements = removeRegions(node.statements, regionName);
                     // @ts-ignore
                     return typescript_1.factory.updateSourceFile(node, statements);
                 }
@@ -92,11 +88,11 @@ var UtilsTypescript;
         };
         // Apply the transformation
         // @ts-ignore
-        var result = (0, typescript_1.transform)(sourceFile, [transformer]);
+        const result = (0, typescript_1.transform)(sourceFile, [transformer]);
         // Get the modified source file
-        var transformedSourceFile = result.transformed[0];
+        const transformedSourceFile = result.transformed[0];
         // Print the transformed source file back to a string
-        var modifiedCode = printer.printFile(transformedSourceFile);
+        const modifiedCode = printer.printFile(transformedSourceFile);
         result.dispose();
         return modifiedCode;
         //#endregion
@@ -108,71 +104,50 @@ var UtilsTypescript;
      * @param regionName - The name of the region to remove.
      * @returns Modified list of statements without the specified regions.
      */
-    var removeRegions = function (statements, regionName) {
-        var e_1, _a, e_2, _b;
+    const removeRegions = (statements, regionName) => {
         //#region @backendFunc
-        var result = [];
-        var stack = [];
-        var currentLevel = 0;
-        try {
-            for (var statements_1 = tslib_1.__values(statements), statements_1_1 = statements_1.next(); !statements_1_1.done; statements_1_1 = statements_1.next()) {
-                var statement = statements_1_1.value;
-                var commentRanges = (0, typescript_1.getLeadingCommentRanges)(statement.getFullText(), 0) || [];
-                var commentText = statement.getFullText();
-                try {
-                    for (var commentRanges_1 = (e_2 = void 0, tslib_1.__values(commentRanges)), commentRanges_1_1 = commentRanges_1.next(); !commentRanges_1_1.done; commentRanges_1_1 = commentRanges_1.next()) {
-                        var range = commentRanges_1_1.value;
-                        var comment = commentText.slice(range.pos, range.end).trim();
-                        // Detect start of a region
-                        var regionMatch = comment.match(/^\/\/#region (.*)/);
-                        if (regionMatch) {
-                            currentLevel++;
-                            var name_1 = regionMatch[1].trim();
-                            // Push the current state of the stack
-                            stack.push({
-                                insideTargetRegion: stack.length > 0
-                                    ? stack[stack.length - 1].insideTargetRegion
-                                    : false,
-                                level: currentLevel,
-                            });
-                            // Check if this region matches the target
-                            if (name_1 === regionName) {
-                                stack[stack.length - 1].insideTargetRegion = true;
-                            }
-                            continue;
-                        }
-                        // Detect end of a region
-                        if (comment.startsWith('//#endregion')) {
-                            if (stack.length > 0 &&
-                                stack[stack.length - 1].level === currentLevel) {
-                                stack.pop();
-                            }
-                            currentLevel--;
-                            continue;
-                        }
+        const result = [];
+        const stack = [];
+        let currentLevel = 0;
+        for (const statement of statements) {
+            const commentRanges = (0, typescript_1.getLeadingCommentRanges)(statement.getFullText(), 0) || [];
+            const commentText = statement.getFullText();
+            for (const range of commentRanges) {
+                const comment = commentText.slice(range.pos, range.end).trim();
+                // Detect start of a region
+                const regionMatch = comment.match(/^\/\/#region (.*)/);
+                if (regionMatch) {
+                    currentLevel++;
+                    const name = regionMatch[1].trim();
+                    // Push the current state of the stack
+                    stack.push({
+                        insideTargetRegion: stack.length > 0
+                            ? stack[stack.length - 1].insideTargetRegion
+                            : false,
+                        level: currentLevel,
+                    });
+                    // Check if this region matches the target
+                    if (name === regionName) {
+                        stack[stack.length - 1].insideTargetRegion = true;
                     }
+                    continue;
                 }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (commentRanges_1_1 && !commentRanges_1_1.done && (_b = commentRanges_1.return)) _b.call(commentRanges_1);
+                // Detect end of a region
+                if (comment.startsWith('//#endregion')) {
+                    if (stack.length > 0 &&
+                        stack[stack.length - 1].level === currentLevel) {
+                        stack.pop();
                     }
-                    finally { if (e_2) throw e_2.error; }
-                }
-                // Check the top of the stack to see if we're inside the target region
-                var insideTargetRegion = stack.length > 0 ? stack[stack.length - 1].insideTargetRegion : false;
-                // Add statements that are not inside the target region
-                if (!insideTargetRegion) {
-                    result.push(statement);
+                    currentLevel--;
+                    continue;
                 }
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (statements_1_1 && !statements_1_1.done && (_a = statements_1.return)) _a.call(statements_1);
+            // Check the top of the stack to see if we're inside the target region
+            const insideTargetRegion = stack.length > 0 ? stack[stack.length - 1].insideTargetRegion : false;
+            // Add statements that are not inside the target region
+            if (!insideTargetRegion) {
+                result.push(statement);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return result;
         //#endregion
@@ -180,29 +155,38 @@ var UtilsTypescript;
     //#endregion
     //#region extract exports from a TypeScript file
     //#region helper function to check if a node is exported
-    var isExported = function (node) {
-        var _a;
+    const isExported = (node) => {
         //#region @backendFunc
         return (((0, typescript_1.getCombinedModifierFlags)(node) & typescript_1.ModifierFlags.Export) !==
-            0 || ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.kind) === typescript_1.SyntaxKind.SourceFile // For top-level exports
+            0 || node.parent?.kind === typescript_1.SyntaxKind.SourceFile // For top-level exports
         );
         //#endregion
     };
-    //#endregion
-    //#region exports from file
     /**
      * Function to extract exports from a TypeScript file
      */
-    UtilsTypescript.exportsFromFile = function (filePath) {
+    UtilsTypescript.exportsFromFile = (filePath) => {
+        //#region @backendFunc
+        if (!filePath.endsWith('.ts')) {
+            return [];
+        }
+        const file = tnp_core_1.Helpers.readFile(filePath);
+        return UtilsTypescript.exportsFromContent(file);
+        //#endregion
+    };
+    /**
+     * Function to extract exports from a TypeScript file
+     */
+    UtilsTypescript.exportsFromContent = (fileContent) => {
         //#region @backendFunc
         // Read the content of the file
-        var sourceCode = tnp_core_1.fse.readFileSync(filePath, 'utf-8');
+        const sourceCode = fileContent;
         // Create a SourceFile object using the TypeScript API
-        var sourceFile = (0, typescript_1.createSourceFile)(filePath, sourceCode, typescript_1.ScriptTarget.Latest, true);
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceCode, typescript_1.ScriptTarget.Latest, true);
         // Array to hold the exports found
-        var exports = [];
+        const exports = [];
         //#region function to recursively check each node in the AST
-        var checkNode = function (node) {
+        const checkNode = (node) => {
             //#region @backendFunc
             // Determine the type and name of export based on node type
             if ((0, typescript_1.isClassDeclaration)(node) && node.name && isExported(node)) {
@@ -212,7 +196,7 @@ var UtilsTypescript;
                 exports.push({ type: 'function', name: node.name.text });
             }
             else if ((0, typescript_1.isVariableStatement)(node) && isExported(node)) {
-                node.declarationList.declarations.forEach(function (declaration) {
+                node.declarationList.declarations.forEach(declaration => {
                     if ((0, typescript_1.isIdentifier)(declaration.name)) {
                         exports.push({
                             type: node.declarationList.flags & typescript_1.NodeFlags.Const
@@ -253,15 +237,14 @@ var UtilsTypescript;
     //#endregion
     //#endregion
     //#region extract class names from ts file or source code
-    UtilsTypescript.extractDefaultClassNameFromString = function (sourceCode) {
+    UtilsTypescript.extractDefaultClassNameFromString = (sourceCode) => {
         //#region @backendFunc
-        var sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceCode, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
-        var defaultClassName = '';
-        var checkNode = function (node) {
-            var _a, _b;
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceCode, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
+        let defaultClassName = '';
+        const checkNode = (node) => {
             if ((0, typescript_1.isClassDeclaration)(node) &&
-                ((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.find(function (m) { return m.kind === typescript_1.SyntaxKind.DefaultKeyword; }))) {
-                defaultClassName = ((_b = node.name) === null || _b === void 0 ? void 0 : _b.text) || '';
+                node.modifiers?.find(m => m.kind === typescript_1.SyntaxKind.DefaultKeyword)) {
+                defaultClassName = node.name?.text || '';
             }
             (0, typescript_1.forEachChild)(node, checkNode);
         };
@@ -269,14 +252,13 @@ var UtilsTypescript;
         return defaultClassName;
         //#endregion
     };
-    UtilsTypescript.extractClassNameFromString = function (sourceCode) {
+    UtilsTypescript.extractClassNameFromString = (sourceCode) => {
         //#region @backendFunc
-        var sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceCode, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
-        var classNames = [];
-        var checkNode = function (node) {
-            var _a;
+        const sourceFile = (0, typescript_1.createSourceFile)('temp.ts', sourceCode, typescript_1.ScriptTarget.Latest, true, typescript_1.ScriptKind.TS);
+        const classNames = [];
+        const checkNode = (node) => {
             if ((0, typescript_1.isClassDeclaration)(node)) {
-                classNames.push(((_a = node.name) === null || _a === void 0 ? void 0 : _a.text) || '');
+                classNames.push(node.name?.text || '');
             }
             (0, typescript_1.forEachChild)(node, checkNode);
         };
@@ -284,68 +266,71 @@ var UtilsTypescript;
         return classNames;
         //#endregion
     };
-    UtilsTypescript.extractClassNamesFromFile = function (absoluteFilePath) {
+    UtilsTypescript.extractClassNamesFromFile = (absoluteFilePath) => {
         //#region @backendFunc
-        var sourceCode = tnp_core_1.Helpers.readFile(absoluteFilePath);
+        if (!absoluteFilePath.endsWith('.ts')) {
+            return [];
+        }
+        const sourceCode = tnp_core_1.Helpers.readFile(absoluteFilePath);
         return UtilsTypescript.extractClassNameFromString(sourceCode);
         //#endregion
     };
-    UtilsTypescript.extractDefaultClassNameFromFile = function (absoluteFilePath) {
+    UtilsTypescript.extractDefaultClassNameFromFile = (absoluteFilePath) => {
         //#region @backendFunc
-        var sourceCode = tnp_core_1.Helpers.readFile(absoluteFilePath);
+        const sourceCode = tnp_core_1.Helpers.readFile(absoluteFilePath);
         return UtilsTypescript.extractDefaultClassNameFromString(sourceCode);
         //#endregion
     };
     //#endregion
     //#region format file(s) with prettier
-    UtilsTypescript.formatFile = function (absPathToFile) {
+    UtilsTypescript.formatFile = (absPathToFile) => {
         //#region @backendFunc
         if (tnp_core_1.Helpers.exists(absPathToFile)) {
-            var execSync = require('child_process').execSync;
-            tnp_core_1.Helpers.logInfo("Formatting file: ".concat(absPathToFile));
+            const { execSync } = require('child_process');
+            tnp_core_1.Helpers.logInfo(`Formatting file: ${absPathToFile}`);
             try {
-                execSync("prettier --write ".concat(tnp_core_1.path.basename(absPathToFile)), {
+                execSync(`prettier --write ${tnp_core_1.path.basename(absPathToFile)}`, {
                     cwd: tnp_core_1.path.dirname(absPathToFile),
                 });
             }
             catch (error) {
-                console.warn("Not able to format file: ".concat(absPathToFile));
+                console.warn(`Not able to format file: ${absPathToFile}`);
             }
+            tnp_core_1.Helpers.taskDone(`Formatting file done.`);
         }
         //#endregion
     };
-    UtilsTypescript.formatAllFilesInsideFolder = function (absPathToFolder) {
+    UtilsTypescript.formatAllFilesInsideFolder = (absPathToFolder) => {
         //#region @backendFunc
         if (tnp_core_1.Helpers.exists(absPathToFolder)) {
-            var execSync = require('child_process').execSync;
+            const { execSync } = require('child_process');
             try {
-                execSync("prettier --write .", { cwd: absPathToFolder });
+                execSync(`prettier --write .`, { cwd: absPathToFolder });
             }
             catch (error) {
-                console.warn("Not able to files in: ".concat(absPathToFolder));
+                console.warn(`Not able to files in: ${absPathToFolder}`);
             }
         }
         //#endregion
     };
     //#endregion
     //#region extract Taon contexts from file
-    UtilsTypescript.getTaonContextFromContent = function (fileContent) {
+    UtilsTypescript.getTaonContextFromContent = (fileContent) => {
         //#region @backendFunc
-        var sourceFile = (0, typescript_1.createSourceFile)('tempFile.ts', fileContent, typescript_1.ScriptTarget.Latest, true);
-        var contextNames = [];
+        const sourceFile = (0, typescript_1.createSourceFile)('tempFile.ts', fileContent, typescript_1.ScriptTarget.Latest, true);
+        const contextNames = [];
         // Recursive function to walk through the AST
-        var visitNode = function (node) {
-            var _a, _b;
+        const visitNode = (node) => {
             try {
                 if ((0, typescript_1.isVariableDeclaration)(node) &&
                     node.initializer &&
                     (0, typescript_1.isCallExpression)(node.initializer)) {
-                    var functionName = '';
-                    var objectName = '';
+                    let functionName = '';
+                    let objectName = '';
                     if ((0, typescript_1.isPropertyAccessExpression)(node.initializer.expression)) {
-                        functionName = ((_a = node.initializer.expression.name) === null || _a === void 0 ? void 0 : _a.text) || '';
+                        functionName = node.initializer.expression.name?.text || '';
                         objectName =
-                            ((_b = node.initializer.expression.expression) === null || _b === void 0 ? void 0 : _b.getText()) || '';
+                            node.initializer.expression.expression?.getText() || '';
                     }
                     else if ((0, typescript_1.isIdentifier)(node.initializer.expression)) {
                         functionName = node.initializer.expression.text;
@@ -372,41 +357,372 @@ var UtilsTypescript;
         return contextNames;
         //#endregion
     };
-    UtilsTypescript.getTaonContextsNamesFromFile = function (tsAbsFilePath) {
+    UtilsTypescript.getTaonContextsNamesFromFile = (tsAbsFilePath) => {
         //#region @backendFunc
         return UtilsTypescript.getTaonContextFromContent(tnp_core_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 selectors = [];
+        const visit = (node) => {
+            if ((0, typescript_1.isClassDeclaration)(node) && node.name) {
+                const decorators = (0, typescript_1.canHaveDecorators)(node)
+                    ? (0, typescript_1.getDecorators)(node)
+                    : undefined;
+                if (decorators) {
+                    for (const decorator of decorators) {
+                        if ((0, typescript_1.isCallExpression)(decorator.expression) &&
+                            (0, typescript_1.isIdentifier)(decorator.expression.expression) &&
+                            decorator.expression.expression.text === 'Component') {
+                            const args = decorator.expression.arguments;
+                            if (args.length > 0 && (0, typescript_1.isObjectLiteralExpression)(args[0])) {
+                                for (const property of args[0].properties) {
+                                    if ((0, typescript_1.isPropertyAssignment)(property) &&
+                                        (0, typescript_1.isIdentifier)(property.name) &&
+                                        property.name.text === 'selector' &&
+                                        (0, typescript_1.isStringLiteral)(property.initializer)) {
+                                        selectors.push({
+                                            className: node.name.text,
+                                            selector: property.initializer.text,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            (0, typescript_1.forEachChild)(node, visit);
+        };
+        visit(sourceFile);
+        return selectors;
+        //#endregion
+    };
+    //#endregion
+    //#region wrap one line with comment
+    UtilsTypescript.wrapWithComment = (oneLineComment, absDestFilePath) => {
+        //#region @backendFunc
+        const ext = tnp_core_1.path.extname(absDestFilePath).toLowerCase();
+        let commentSyntax;
+        switch (ext) {
+            case '.ts':
+            case '.js':
+            case '.jsonc':
+            case '.sh':
+                commentSyntax = `// ${oneLineComment}`;
+                break;
+            case '.html':
+                commentSyntax = `<!-- ${oneLineComment} -->`;
+                break;
+            case '.css':
+            case '.scss':
+            case '.sass':
+                commentSyntax = `/* ${oneLineComment} */`;
+                break;
+            default:
+                console.warn(`Unknown file extension: ${ext}`);
+                commentSyntax = oneLineComment;
+        }
+        return commentSyntax;
+        //#endregion
+    };
+    //#endregion
+    //#region ser or add exported variable with AST
+    // Helper to check if a node has 'export' in its modifiers
+    // const hasExportModifier = (
+    //   modifiers: ts.NodeArray<ts.Modifier> | undefined,
+    // ) => {
+    //   return (
+    //     !!modifiers && modifiers.some(m => m.kind === SyntaxKind.ExportKeyword)
+    //   );
+    // };
+    /**
+     * Attempts to set or add an exported const with given name and value.
+     */
+    UtilsTypescript.setValueToVariableInTsFile = (tsAbsFilePath, variableName, valueOfVariable, addIfNotExists = true) => {
+        //#region @backendFunc
+        const sourceText = tnp_core_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
+        const transformer = (context) => {
+            const { factory } = context;
+            return (rootNode) => {
+                let variableFound = false;
+                const visit = (node) => {
+                    // Check for "export const <variableName> = ...;"
+                    if ((0, typescript_1.isVariableStatement)(node)
+                    // && hasExportModifier(node.modifiers as any)
+                    ) {
+                        const declList = node.declarationList;
+                        const newDeclarations = declList.declarations.map(decl => {
+                            if ((0, typescript_1.isIdentifier)(decl.name) && decl.name.text === variableName) {
+                                variableFound = true;
+                                // Create a new initializer. If valueOfVariable is a string,
+                                // we wrap it with quotes; otherwise, create a numeric or object literal.
+                                let initializer;
+                                if (typeof valueOfVariable === 'string') {
+                                    initializer = factory.createStringLiteral(valueOfVariable);
+                                }
+                                else if (typeof valueOfVariable === 'number') {
+                                    initializer = factory.createNumericLiteral(valueOfVariable);
+                                }
+                                else {
+                                    // Fallback: wrap JSON string => parse with TS
+                                    // Or you can create a more sophisticated approach for arrays/objects
+                                    initializer = factory.createIdentifier(JSON.stringify(valueOfVariable));
+                                }
+                                // Return a new variable declaration with the updated initializer
+                                return factory.updateVariableDeclaration(decl, decl.name, decl.exclamationToken, decl.type, initializer);
+                            }
+                            return decl;
+                        });
+                        // Return a new VariableStatement if we changed anything
+                        return factory.updateVariableStatement(node, node.modifiers, factory.updateVariableDeclarationList(declList, newDeclarations));
+                    }
+                    return (0, typescript_1.visitEachChild)(node, visit, context);
+                };
+                let updatedRoot = (0, typescript_1.visitNode)(rootNode, visit);
+                // If variable not found and addIfNotExists === true, add a new export statement
+                if (!variableFound && addIfNotExists) {
+                    // Create something like: export const <variableName> = <valueOfVariable>;
+                    let initializer;
+                    if (typeof valueOfVariable === 'string') {
+                        initializer = factory.createStringLiteral(valueOfVariable);
+                    }
+                    else if (typeof valueOfVariable === 'number') {
+                        initializer = factory.createNumericLiteral(valueOfVariable);
+                    }
+                    else {
+                        initializer = factory.createIdentifier(JSON.stringify(valueOfVariable));
+                    }
+                    const newVarStatement = factory.createVariableStatement([factory.createModifier(typescript_1.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([
+                        factory.createVariableDeclaration(factory.createIdentifier(variableName), 
+                        /* exclamationToken */ undefined, 
+                        /* type */ undefined, initializer),
+                    ], typescript_1.NodeFlags.Const));
+                    // Append it to the end of the file
+                    const newStatements = [...updatedRoot.statements, newVarStatement];
+                    updatedRoot = factory.updateSourceFile(updatedRoot, newStatements);
+                }
+                return updatedRoot;
+            };
+        };
+        // Apply the transformer
+        const result = (0, typescript_1.transform)(sourceFile, [transformer]);
+        const transformedSourceFile = result.transformed[0];
+        // Print the new AST back to text
+        const printer = (0, typescript_1.createPrinter)();
+        const newContent = printer.printFile(transformedSourceFile);
+        // Overwrite the file
+        tnp_core_1.Helpers.writeFile(tsAbsFilePath, newContent);
+        result.dispose();
+        //#endregion
+    };
+    //#endregion
+    //#region recognize imports from file
+    //#region helpers / ts import export class
+    class TsImportExport {
+        type;
+        /**
+         * ORIGNAL
+         * Name of the file that is being imported/exported
+         * with parenthesis included
+         */
+        embeddedPathToFile;
+        /**
+         * same as cleanEmbeddedPathToFile but without quotes (parenthesis)
+         */
+        cleanEmbeddedPathToFile;
+        removeStartEndQuotes(str) {
+            return str.replace(/^['"`]/, '').replace(/['"`]$/, '');
+        }
+        /**
+         * RESULT OF PROCESSING
+         */
+        embeddedPathToFileResult;
+        /**
+         * @deprecated use cleanEmbeddedPathToFile
+         */
+        packageName;
+        isIsomorphic;
+        startRow;
+        startCol;
+        /**
+         * it will extract part of the file content
+         * that is between startRow, startCol and endRow, endCol
+         * and contains import/export/require statement
+         */
+        getStringPartFrom(wholeContentOfFile) {
+            const lines = wholeContentOfFile.split('\n');
+            // Convert 1-based row indices to 0-based
+            const startRowIndex = this.startRow - 1;
+            const endRowIndex = this.endRow - 1;
+            // Ensure indices are within bounds
+            if (startRowIndex >= lines.length || endRowIndex >= lines.length) {
+                throw new Error('Row index out of bounds.');
+            }
+            let extractedLines = [];
+            for (let i = startRowIndex; i <= endRowIndex; i++) {
+                let line = lines[i];
+                if (i === startRowIndex && i === endRowIndex) {
+                    // Same row: extract from startCol to endCol
+                    extractedLines.push(line.substring(this.startCol - 1, this.endCol));
+                }
+                else if (i === startRowIndex) {
+                    // First row: extract from startCol to end
+                    extractedLines.push(line.substring(this.startCol - 1));
+                }
+                else if (i === endRowIndex) {
+                    // Last row: extract from beginning to endCol
+                    extractedLines.push(line.substring(0, this.endCol));
+                }
+                else {
+                    // Whole row in between
+                    extractedLines.push(line);
+                }
+            }
+            return extractedLines.join('\n');
+        }
+        endRow;
+        endCol;
+        parenthesisType;
+        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;
+        }
+    }
+    UtilsTypescript.TsImportExport = TsImportExport;
+    //#endregion
+    //#region helpers / get quote type
+    const getQuoteType = (text) => {
+        if (text.startsWith('`'))
+            return 'tics';
+        if (text.startsWith("'"))
+            return 'single';
+        return 'double';
+    };
+    //#endregion
+    const extractImportExportElements = (node) => {
+        const elements = [];
+        if ((0, typescript_1.isImportDeclaration)(node) && node.importClause) {
+            // Check if there are named imports inside { }
+            if (node.importClause.namedBindings &&
+                (0, typescript_1.isNamedImports)(node.importClause.namedBindings)) {
+                elements.push(...node.importClause.namedBindings.elements.map(el => el.name.text));
+            }
+        }
+        else if ((0, typescript_1.isExportDeclaration)(node) && node.exportClause) {
+            // Check if there are named exports inside { }
+            if ((0, typescript_1.isNamedExports)(node.exportClause)) {
+                elements.push(...node.exportClause.elements.map(el => el.name.text));
+            }
+        }
+        return elements;
+    };
+    UtilsTypescript.recognizeImportsFromFile = (fileAbsPAth) => {
+        //#region @backendFunc
+        const content = tnp_core_1.Helpers.readFile(fileAbsPAth);
+        return UtilsTypescript.recognizeImportsFromContent(content);
+        //#endregion
+    };
+    UtilsTypescript.recognizeImportsFromContent = (fileContent) => {
+        //#region @backendFunc
+        if (!fileContent) {
+            return [];
+        }
+        const sourceFile = (0, typescript_1.createSourceFile)('file.ts', // a name for the file
+        fileContent, typescript_1.ScriptTarget.Latest, true);
+        const results = [];
+        const visit = (node) => {
+            // Check for dynamic import expressions specifically
+            if ((0, typescript_1.isCallExpression)(node) &&
+                node.expression.kind === typescript_1.SyntaxKind.ImportKeyword) {
+                const args = node.arguments;
+                if (args.length) {
+                    const arg = args[0];
+                    const specifier = arg.getText(sourceFile);
+                    const parenthesisType = getQuoteType(specifier);
+                    results.push(new TsImportExport('async-import', specifier, sourceFile.getLineAndCharacterOfPosition(node.getStart()), sourceFile.getLineAndCharacterOfPosition(node.getEnd()), parenthesisType));
+                }
+            }
+            if ((0, typescript_1.isImportDeclaration)(node) || (0, typescript_1.isExportDeclaration)(node)) {
+                const specifier = node.moduleSpecifier
+                    ? node.moduleSpecifier.getText(sourceFile)
+                    : '';
+                const parenthesisType = getQuoteType(specifier);
+                const type = node.kind === typescript_1.SyntaxKind.ImportDeclaration ? 'import' : 'export';
+                const importExportElements = extractImportExportElements(node);
+                results.push(new TsImportExport(type, specifier, sourceFile.getLineAndCharacterOfPosition(node.getStart()), sourceFile.getLineAndCharacterOfPosition(node.getEnd()), parenthesisType, importExportElements));
+            }
+            if ((0, typescript_1.isCallExpression)(node) &&
+                node.expression.getText(sourceFile) === 'require') {
+                const args = node.arguments;
+                if (args.length > 0) {
+                    const arg = args[0];
+                    const specifier = arg.getText(sourceFile);
+                    const parenthesisType = getQuoteType(specifier);
+                    results.push(new TsImportExport('require', specifier, sourceFile.getLineAndCharacterOfPosition(arg.getStart()), sourceFile.getLineAndCharacterOfPosition(arg.getEnd()), parenthesisType));
+                }
+            }
+            (0, typescript_1.forEachChild)(node, visit);
+        };
+        (0, typescript_1.forEachChild)(sourceFile, visit);
+        return results;
+        //#endregion
+    };
+    //#endregion
 })(UtilsTypescript || (exports.UtilsTypescript = UtilsTypescript = {}));
 //#endregion
 //#region utils http
 var UtilsHttp;
 (function (UtilsHttp) {
-    var _this = this;
     //#region utils http / start http server
-    UtilsHttp.startHttpServer = function (cwd, port) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var app, server;
-        return tslib_1.__generator(this, function (_a) {
-            app = express();
-            // Serve static files from the provided cwd
-            app.use(express.static(cwd));
-            // Catch-all to handle any invalid routes (404 errors)
-            app.use(function (req, res) {
-                res.status(404).send('File not found');
-            });
-            server = app.listen(port, function () {
-                console.log("Server started at http://localhost:".concat(port, ", serving files from ").concat(cwd));
+    UtilsHttp.startHttpServer = async (cwd, port) => {
+        //#region @backendFunc
+        const express = require('express');
+        const app = express();
+        // Serve static files from the provided cwd
+        app.use(express.static(cwd));
+        // Catch-all to handle any invalid routes (404 errors)
+        app.use((req, res) => {
+            res.status(404).send('File not found');
+        });
+        // Start the server
+        const server = app.listen(port, () => {
+            console.log(`Server started at http://localhost:${port}, serving files from ${cwd}`);
+        });
+        return new Promise((resolve, reject) => {
+            console.log(`Server started at http://localhost:${port}`);
+            // Handle Ctrl+C (SIGINT) gracefully
+            process.on('SIGINT', () => {
+                server.close(() => resolve());
             });
-            return [2 /*return*/, new Promise(function (resolve, reject) {
-                    console.log("Server started at http://localhost:".concat(port));
-                    // Handle Ctrl+C (SIGINT) gracefully
-                    process.on('SIGINT', function () {
-                        server.close(function () { return resolve(); });
-                    });
-                })];
         });
-    }); };
+        //#endregion
+    };
     //#endregion
 })(UtilsHttp || (exports.UtilsHttp = UtilsHttp = {}));
 //#endregion
@@ -416,13 +732,13 @@ var UtilsMd;
     /**
      * extract assets pathes from .md file
      */
-    UtilsMd.getAssets = function (mdfileContent) {
+    UtilsMd.getAssets = (mdfileContent) => {
         //#region @backendFunc
         // Regular expressions for detecting assets
-        var markdownImgRegex = /!\[.*?\]\((.*?)\)/g; // Markdown image syntax ![alt](src)
-        var htmlImgRegex = /<img.*?src=["'](.*?)["']/g; // HTML image syntax <img src="path">
-        var assets = [];
-        var match;
+        const markdownImgRegex = /!\[.*?\]\((.*?)\)/g; // Markdown image syntax ![alt](src)
+        const htmlImgRegex = /<img.*?src=["'](.*?)["']/g; // HTML image syntax <img src="path">
+        const assets = [];
+        let match;
         // Extract Markdown image links
         while ((match = markdownImgRegex.exec(mdfileContent)) !== null) {
             assets.push(match[1]); // Get the image path
@@ -431,21 +747,21 @@ var UtilsMd;
         while ((match = htmlImgRegex.exec(mdfileContent)) !== null) {
             assets.push(match[1]); // Get the image path
         }
-        return assets.map(function (r) { return r.replace(new RegExp(/^\.\//), ''); });
+        return assets.map(r => r.replace(new RegExp(/^\.\//), ''));
         //#endregion
     };
     /**
      * Extract links to other Markdown files from a given Markdown content.
      * @param mdfileContent
      */
-    UtilsMd.getLinksToOtherMdFiles = function (mdfileContent) {
+    UtilsMd.getLinksToOtherMdFiles = (mdfileContent) => {
         //#region @backendFunc
         // Regex pattern to match Markdown and HTML links to .md files
-        var mdLinkPattern = /\[.*?\]\(([^)]+\.md)\)/g; // Matches [text](link.md)
+        const mdLinkPattern = /\[.*?\]\(([^)]+\.md)\)/g; // Matches [text](link.md)
         // const htmlLinkPattern = /<a\s+href=["']([^"']+\.md)["'].*?>/g; // Matches <a href="link.md">
-        var links = new Set(); // Use a Set to avoid duplicate links
+        const links = new Set(); // Use a Set to avoid duplicate links
         // Find all Markdown-style links
-        var match;
+        let match;
         while ((match = mdLinkPattern.exec(mdfileContent)) !== null) {
             links.add(match[1]);
         }
@@ -463,23 +779,23 @@ var UtilsMd;
      * @param level - The number of levels to go up (default is 1).
      * @returns The modified content with updated asset paths.
      */
-    UtilsMd.moveAssetsPathesToLevel = function (mdfileContent, level) {
-        if (level === void 0) { level = 1; }
+    UtilsMd.moveAssetsPathesToLevel = (mdfileContent, level = 1) => {
         //#region @backendFunc
+        mdfileContent = mdfileContent || '';
         // Regular expressions for detecting assets
-        var markdownImgRegex = /(!\[.*?\]\()(\.\/|\.\.\/.*?)(\))/g; // Matches ![alt](./path or ../path)
-        var htmlImgRegex = /(<img.*?src=["'])(\.\/|\.\.\/.*?)(["'])/g; // Matches <img src="./path or ../path">
+        const markdownImgRegex = /(!\[.*?\]\()(\.\/|\.\.\/.*?)(\))/g; // Matches ![alt](./path or ../path)
+        const htmlImgRegex = /(<img.*?src=["'])(\.\/|\.\.\/.*?)(["'])/g; // Matches <img src="./path or ../path">
         // Calculate how many "../" segments to prepend based on the level
-        var prefix = '../'.repeat(level);
+        const prefix = '../'.repeat(level);
         // Replace the paths in Markdown images
-        var updatedMarkdown = mdfileContent.replace(markdownImgRegex, function (_, prefixText, path, suffix) {
+        const updatedMarkdown = mdfileContent.replace(markdownImgRegex, (_, prefixText, path, suffix) => {
             // Add the "../" prefix and normalize the path
-            return "".concat(prefixText).concat(prefix).concat(path.replace(/^\.\//, '').replace(/^\.\.\//, '')).concat(suffix);
+            return `${prefixText}${prefix}${path.replace(/^\.\//, '').replace(/^\.\.\//, '')}${suffix}`;
         });
         // Replace the paths in HTML images
-        var updatedHtml = updatedMarkdown.replace(htmlImgRegex, function (_, prefixText, path, suffix) {
+        const updatedHtml = updatedMarkdown.replace(htmlImgRegex, (_, prefixText, path, suffix) => {
             // Add the "../" prefix and normalize the path
-            return "".concat(prefixText).concat(prefix).concat(path.replace(/^\.\//, '').replace(/^\.\.\//, '')).concat(suffix);
+            return `${prefixText}${prefix}${path.replace(/^\.\//, '').replace(/^\.\.\//, '')}${suffix}`;
         });
         return updatedHtml;
         //#endregion
@@ -494,25 +810,32 @@ var UtilsQuickFixes;
      *
      * @param node_modules/sql.js/dist/sql-wasm.js
      */
-    function replaceSQLliteFaultyCode(contentofSQLWasmJS) {
+    UtilsQuickFixes.replaceSQLliteFaultyCode = (contentofSQLWasmJS) => {
         //#region @backendFunc
-        var replace = [
+        const replace = [
             [
-                "var packageJson = JSON.parse(fs.readFileSync(__nccwpck_require__.ab " +
-                    "+ \"package.json\").toString());",
-                "var packageJson = JSON.parse(fs.existsSync(__nccwpck_require__.ab + " +
-                    "\"package.json\") && fs.readFileSync(__nccwpck_require__.ab + \"package.json\").toString());",
+                `var packageJson = JSON.parse(fs.readFileSync(__nccwpck_require__.ab ` +
+                    `+ "package.json").toString());`,
+                `var packageJson = JSON.parse(fs.existsSync(__nccwpck_require__.ab + ` +
+                    `"package.json") && fs.readFileSync(__nccwpck_require__.ab + "package.json").toString());`,
             ],
             ['module = undefined;', '/* module = undefined ; */'],
         ];
-        replace.forEach(function (r) {
+        replace.forEach(r => {
             contentofSQLWasmJS = contentofSQLWasmJS.replace(r[0], r[1]);
         });
         return contentofSQLWasmJS;
         //#endregion
-    }
-    UtilsQuickFixes.replaceSQLliteFaultyCode = replaceSQLliteFaultyCode;
+    };
     //#endregion
+    /**
+     * for some reason electron is being bundled - and it is not needed for cli
+     */
+    UtilsQuickFixes.replaceElectronWithNothing = (jsContent) => {
+        //#region @backendFunc
+        return jsContent.replace(`mod${'ule.exports'} = ${'requ' + 'ire'}("electron");`, '');
+        //#endregion
+    };
 })(UtilsQuickFixes || (exports.UtilsQuickFixes = UtilsQuickFixes = {}));
 //#endregion
 //# sourceMappingURL=utils.js.map