datagrok-tools 4.13.77 → 4.13.79

package/bin/utils/func-generation.js

@@ -9,7 +9,7 @@ exports.generateExport = generateExport;
 exports.generateFunc = generateFunc;
 exports.generateImport = generateImport;
 exports.getFuncAnnotation = getFuncAnnotation;
-exports.reservedDecorators = exports.pseudoParams = exports.headerParams = void 0;
+exports.typesToAnnotation = exports.reservedDecorators = exports.pseudoParams = exports.headerParams = void 0;
 /* eslint-disable no-unused-vars */
 /* eslint-disable valid-jsdoc */
 
@@ -21,6 +21,7 @@ let pseudoParams = exports.pseudoParams = /*#__PURE__*/function (pseudoParams) {
   return pseudoParams;
 }({});
 let FUNC_TYPES = exports.FUNC_TYPES = /*#__PURE__*/function (FUNC_TYPES) {
+  FUNC_TYPES["APP"] = "app";
   FUNC_TYPES["CELL_RENDERER"] = "cellRenderer";
   FUNC_TYPES["FILE_EXPORTER"] = "fileExporter";
   FUNC_TYPES["FILE_IMPORTER"] = "file-handler";
@@ -28,8 +29,43 @@ let FUNC_TYPES = exports.FUNC_TYPES = /*#__PURE__*/function (FUNC_TYPES) {
   FUNC_TYPES["SETTINGS_EDITOR"] = "packageSettingsEditor";
   FUNC_TYPES["VIEWER"] = "viewer";
   FUNC_TYPES["FILTER"] = "filter";
+  FUNC_TYPES["AUTOSTART"] = "autostart";
+  FUNC_TYPES["INIT"] = "init";
+  FUNC_TYPES["EDITOR"] = "editor";
+  FUNC_TYPES["PANEL"] = "panel";
+  FUNC_TYPES["FOLDER_VIEWER"] = "folderViewer";
+  FUNC_TYPES["SEM_TYPE_DETECTOR"] = "semTypeDetector";
+  FUNC_TYPES["DASHBOARD"] = "dashboard";
+  FUNC_TYPES["FUNCTION_ANALYSIS"] = "functionAnalysis";
+  FUNC_TYPES["CONVERTER"] = "converter";
   return FUNC_TYPES;
 }({});
+const typesToAnnotation = exports.typesToAnnotation = {
+  'DataFrame': 'dataframe',
+  'DG.DataFrame': 'dataframe',
+  'Column': 'column',
+  'DG.Column': 'column',
+  'ColumnList': 'column_list',
+  'DG.ColumnList': 'column_list',
+  'FileInfo': 'file',
+  'DG.FileInfo': 'file',
+  'Uint8Array': 'blob',
+  'number': 'double',
+  'boolean': 'bool',
+  'dayjs.Dayjs': 'datetime',
+  'Dayjs': 'datetime',
+  'graphics': 'graphics',
+  'DG.View': 'view',
+  'View': 'view',
+  'DG.Widget': 'widget',
+  'Widget': 'widget',
+  'DG.FuncCall': 'funccall',
+  'FuncCall': 'funccall',
+  'DG.SemanticValue': 'semantic_value',
+  'SemanticValue': 'semantic_value',
+  'any': 'dynamic'
+};
+
 /** Generates an annotation header for a function based on provided metadata. */
 function getFuncAnnotation(data, comment = '//', sep = '\n') {
   const isFileViewer = data.tags?.includes(FUNC_TYPES.FILE_VIEWER) ?? false;
@@ -38,24 +74,48 @@ function getFuncAnnotation(data, comment = '//', sep = '\n') {
   if (data.name) s += `${comment}name: ${data.name}${sep}`;
   if (pseudoParams.EXTENSION in data && data.tags != null && data.tags.includes(FUNC_TYPES.FILE_EXPORTER)) s += `${comment}description: Save as ${data[pseudoParams.EXTENSION]}${sep}`;else if (data.description) s += `${comment}description: ${data.description}${sep}`;
   if (data.tags) {
-    s += `${comment}tags: ${isFileViewer && data[pseudoParams.EXTENSIONS] ? data.tags.concat(data[pseudoParams.EXTENSIONS].map(ext => 'fileViewer-' + ext)).join() : data.tags.join()}${sep}`;
+    s += `${comment}tags: ${isFileViewer && data[pseudoParams.EXTENSIONS] ? data.tags.concat(data[pseudoParams.EXTENSIONS].map(ext => 'fileViewer-' + ext)).join(', ') : data.tags.join(', ')}${sep}`;
   }
-  if (data.inputs) {
-    for (const input of data.inputs) {
-      s += comment + 'input: ' + (isFileImporter && data[pseudoParams.INPUT_TYPE] ? data[pseudoParams.INPUT_TYPE] : input.type) + (input.name ? ` ${input.name}` : '') + sep;
+  for (let input of data.inputs ?? []) {
+    if (!input) continue;
+    let type = input?.type;
+    let isArray = false;
+    if (type?.includes(`[]`)) {
+      type = type.replace(/\[\]$/, '');
+      isArray = true;
     }
+    const annotationType = typesToAnnotation[type ?? ''];
+    if (input?.options?.type) type = input?.options?.type;else if (annotationType) {
+      if (isArray) type = `list<${annotationType}>`;else type = annotationType;
+    } else type = 'dynamic';
+    console.log(input);
+    const options = input?.options?.options ? buildStringOfOptions(input.options.options ?? {}) : '';
+    const functionName = (input.options?.name ? input?.options?.name ?? ` ${input.name?.replaceAll('.', '')}` : '')?.trim();
+    s += comment + 'input: ' + type + ' ' + functionName + (input.defaultValue !== undefined ? `= ${input.defaultValue}` : '') + ' ' + options.replaceAll('"', '\'') + sep;
   }
   if (data.outputs) {
     for (const output of data.outputs) s += comment + 'output: ' + output.type + (output.name ? ` ${output.name}` : '') + sep;
   }
+  if (data.meta) {
+    for (let entry of Object.entries(data.meta)) s += `${comment}meta.${entry[0]}: ${entry[1]}${sep}`;
+  }
   for (const parameter in data) {
-    if (parameter === pseudoParams.EXTENSION || parameter === pseudoParams.INPUT_TYPE) continue;else if (parameter === pseudoParams.EXTENSIONS) {
+    if (parameter === pseudoParams.EXTENSION || parameter === pseudoParams.INPUT_TYPE || parameter === 'meta') continue;else if (parameter === pseudoParams.EXTENSIONS) {
       if (isFileViewer) continue;
       s += `${comment}meta.ext: ${data[parameter]}${sep}`;
     } else if (!headerParams.includes(parameter)) s += `${comment}meta.${parameter}: ${data[parameter]}${sep}`;
   }
   return s;
 }
+function buildStringOfOptions(options) {
+  let optionsInString = [];
+  for (const [key, value] of Object.entries(options ?? {})) {
+    let val = value;
+    if (Array.isArray(value)) val = JSON.stringify(value);
+    optionsInString.push(`${key}: ${val}`);
+  }
+  return `{ ${optionsInString.join('; ')} }`;
+}
 const reservedDecorators = exports.reservedDecorators = {
   viewer: {
     metadata: {
@@ -136,6 +196,133 @@ const reservedDecorators = exports.reservedDecorators = {
       }]
     },
     genFunc: generateFunc
+  },
+  func: {
+    metadata: {
+      tags: [],
+      inputs: [],
+      outputs: [{
+        name: 'result',
+        type: 'dynamic'
+      }]
+    },
+    genFunc: generateFunc
+  },
+  app: {
+    metadata: {
+      tags: [FUNC_TYPES.APP],
+      inputs: [],
+      outputs: [{
+        name: 'result',
+        type: 'view'
+      }]
+    },
+    genFunc: generateFunc
+  },
+  autostart: {
+    metadata: {
+      tags: [FUNC_TYPES.AUTOSTART],
+      inputs: [],
+      outputs: []
+    },
+    genFunc: generateFunc
+  },
+  init: {
+    metadata: {
+      tags: [FUNC_TYPES.INIT],
+      inputs: [],
+      outputs: []
+    },
+    genFunc: generateFunc
+  },
+  editor: {
+    metadata: {
+      tags: [FUNC_TYPES.EDITOR],
+      inputs: [{
+        name: 'call',
+        type: 'funccall'
+      }],
+      outputs: []
+    },
+    genFunc: generateFunc
+  },
+  panel: {
+    metadata: {
+      tags: [FUNC_TYPES.PANEL],
+      inputs: [],
+      outputs: [{
+        name: 'result',
+        type: 'widget'
+      }]
+    },
+    genFunc: generateFunc
+  },
+  folderViewer: {
+    metadata: {
+      tags: [FUNC_TYPES.FOLDER_VIEWER],
+      inputs: [{
+        name: 'folder',
+        type: 'file'
+      }, {
+        name: 'files',
+        type: 'list<file>'
+      }],
+      outputs: [{
+        name: 'result',
+        type: 'widget'
+      }]
+    },
+    genFunc: generateFunc
+  },
+  semTypeDetector: {
+    metadata: {
+      tags: [FUNC_TYPES.SEM_TYPE_DETECTOR],
+      inputs: [{
+        name: 'col',
+        type: 'column'
+      }],
+      outputs: [{
+        name: 'result',
+        type: 'string'
+      }]
+    },
+    genFunc: generateFunc
+  },
+  dashboard: {
+    metadata: {
+      tags: [FUNC_TYPES.DASHBOARD],
+      inputs: [],
+      outputs: [{
+        name: 'result',
+        type: 'widget'
+      }]
+    },
+    genFunc: generateFunc
+  },
+  functionAnalysis: {
+    metadata: {
+      tags: [FUNC_TYPES.FUNCTION_ANALYSIS],
+      inputs: [],
+      outputs: [{
+        name: 'result',
+        type: 'view'
+      }]
+    },
+    genFunc: generateFunc
+  },
+  converter: {
+    metadata: {
+      tags: [FUNC_TYPES.CONVERTER],
+      inputs: [{
+        name: 'value',
+        type: 'dynamic'
+      }],
+      outputs: [{
+        name: 'result',
+        type: 'dynamic'
+      }]
+    },
+    genFunc: generateFunc
   }
 };
 
@@ -145,8 +332,10 @@ function generateClassFunc(annotation, className, sep = '\n') {
 }
 
 /** Generates a DG function. */
-function generateFunc(annotation, funcName, sep = '\n') {
-  return annotation + `export function _${funcName}() {${sep}  return ${funcName}();${sep}}${sep.repeat(2)}`;
+function generateFunc(annotation, funcName, sep = '\n', className = '', inputs = []) {
+  let funcSigNature = inputs.map(e => `${e.name}: ${e.type}`).join(', ');
+  let funcArguments = inputs.map(e => e.name).join(', ');
+  return annotation + `export function _${funcName}(${funcSigNature}) {${sep}  return ${className.length > 0 ? `${className}.` : ''}${funcName}(${funcArguments});${sep}}${sep.repeat(2)}`;
 }
 function generateImport(className, path, sep = '\n') {
   return `import {${className}} from '${path}';${sep}`;

package/bin/utils/test-utils.js

@@ -90,6 +90,22 @@ async function getBrowserPage(puppeteer, params = defaultLaunchParameters) {
   url = await getWebUrl(url, token);
   console.log(`Using web root: ${url}`);
   const browser = await puppeteer.launch(params);
+  if (params.debug) {
+    const targets = await browser.targets();
+    const devtoolsTarget = targets.find(t => {
+      return t.type() === 'other' && t.url().startsWith('devtools://');
+    });
+    if (devtoolsTarget) {
+      const client = await devtoolsTarget.createCDPSession();
+      await client.send('Runtime.enable');
+      await client.send('Runtime.evaluate', {
+        expression: `
+      window.UI.viewManager.showView('network');
+      window.UI.dockController.setDockSide('bottom')
+    `
+      });
+    }
+  }
   const page = await browser.newPage();
   await page.setViewport({
     width: 1920,
@@ -304,7 +320,7 @@ function saveCsvResults(stringToSave, csvReportDir) {
   _fs.default.writeFileSync(csvReportDir, modifiedStrings.join('\n'), 'utf8');
   color.info('Saved `test-report.csv`\n');
 }
-async function helloTests(testsParams, stopOnFail) {
+async function runTests(testsParams, stopOnFail) {
   let failed = false;
   let verbosePassed = "";
   let verboseSkipped = "";
@@ -348,7 +364,8 @@ async function helloTests(testsParams, stopOnFail) {
       row["flaking"] = success && window.DG.Test.isReproducing;
       df.changeColumnType('result', window.DG.COLUMN_TYPE.STRING);
       df.changeColumnType('logs', window.DG.COLUMN_TYPE.STRING);
-      df.changeColumnType('memoryDelta', window.DG.COLUMN_TYPE.BIG_INT);
+      // df.changeColumnType('memoryDelta', (<any>window).DG.COLUMN_TYPE.BIG_INT);
+
       if (resultDF === undefined) resultDF = df;else resultDF = resultDF.append(df);
       if (row["skipped"]) {
         verboseSkipped += `Test result : Skipped : ${time} : ${category}: ${testName} :  ${result}\n`;
@@ -398,7 +415,7 @@ async function helloTests(testsParams, stopOnFail) {
 }
 async function runBrowser(testExecutionData, browserOptions, browsersId, testInvocationTimeout = 3600000) {
   let testsToRun = {
-    func: helloTests.toString(),
+    func: runTests.toString(),
     tests: testExecutionData
   };
   return await timeout(async () => {
@@ -433,8 +450,8 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
       if (options.ciCd) window.DG.Test.isCiCd = true;
       if (options.debug) window.DG.Test.isInDebug = true;
       return new Promise((resolve, reject) => {
-        window.helloTests = eval('(' + testData.func + ')');
-        window.helloTests(testData.tests, options.stopOnTimeout).then(results => {
+        window.runTests = eval('(' + testData.func + ')');
+        window.runTests(testData.tests, options.stopOnTimeout).then(results => {
           resolve(results);
         }).catch(e => {
           resolve({

package/package-template/package.json

@@ -7,7 +7,7 @@
     "datagrok-api": "^1.21.3",
     "cash-dom": "^8.1.5",
     "dayjs": "^1.11.13",
-    "@datagrok-libraries/utils": "^4.3.6"
+    "@datagrok-libraries/utils": "^4.5.7"
   },
   "devDependencies": {
     "datagrok-tools": "latest",

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "datagrok-tools",
-  "version": "4.13.77",
+  "version": "4.13.79",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {
     "@babel/parser": "^7.26.10",
     "@babel/runtime": "^7.23.8",
     "@babel/traverse": "^7.23.7",
+    "@typescript-eslint/typescript-estree": "^8.31.1",
+    "@typescript-eslint/visitor-keys": "^8.31.1",
     "archiver": "^4.0.2",
     "archiver-promise": "^1.0.0",
+    "estraverse": "^5.3.0",
     "fs": "^0.0.1-security",
     "ignore-walk": "^3.0.4",
     "inquirer": "^7.3.3",
@@ -19,7 +22,7 @@
     "os": "^0.1.2",
     "papaparse": "^5.4.1",
     "path": "^0.12.7",
-    "puppeteer": "^22.10.0",
+    "puppeteer": "22.10.0",
     "puppeteer-screen-recorder": "3.0.3"
   },
   "scripts": {

package/plugins/func-gen-plugin.js

@@ -1,75 +1,233 @@
-const fs = require('fs');
-const path = require('path');
-const {parse} = require('@babel/parser');
-const traverse = require('@babel/traverse').default;
-const {reservedDecorators, getFuncAnnotation, generateImport, generateExport} = require('../bin/utils/func-generation');
+const fs = require("fs");
+const path = require("path");
 
+const tsParser = require("@typescript-eslint/typescript-estree");
+const generate = require('@babel/generator').default;
+
+const {
+  reservedDecorators,
+  getFuncAnnotation,
+  generateImport,
+  generateExport,
+  typesToAnnotation
+} = require("../bin/utils/func-generation");
+
+const baseImport = '\nimport * as DG from \'datagrok-api/dg\';\n\n';
 
 class FuncGeneratorPlugin {
-  constructor(options = {outputPath: './src/package.g.ts'}) {
+  constructor(options = { outputPath: "./src/package.g.ts" }) {
     this.options = options;
   }
 
   apply(compiler) {
-    const srcDirPath = path.join(compiler.context, 'src');
-    let packageFilePath = path.join(srcDirPath, 'package.ts');
-    if(!fs.existsSync(packageFilePath))
-      packageFilePath = path.join(srcDirPath, 'package.js');
+    const srcDirPath = path.join(compiler.context, "src");
+    let packageFilePath = path.join(srcDirPath, "package.ts");
+    if (!fs.existsSync(packageFilePath))
+      packageFilePath = path.join(srcDirPath, "package.js");
     const tsFiles = this._getTsFiles(srcDirPath);
     const genImports = [];
     const genExports = [];
 
-    compiler.hooks.compilation.tap('FuncGeneratorPlugin', (_compilation) => {
+    compiler.hooks.compilation.tap("FuncGeneratorPlugin", (_compilation) => {
       this._clearGeneratedFile();
 
       for (const file of tsFiles) {
-        const content = fs.readFileSync(file, 'utf-8');
-        if (!content)
-          continue;
-        const ast = parse(content, {
-          sourceType: 'module',
-          plugins: ['typescript', [
-            'decorators',
-            {decoratorsBeforeExport: true},
-          ]],
+        const content = fs.readFileSync(file, "utf-8");
+        if (!content) continue;
+        const ast = tsParser.parse(content, {
+          sourceType: "module",
+          plugins: [
+            ["decorators", { decoratorsBeforeExport: true }],
+            "classProperties",
+            "typescript",
+          ],
         });
         const functions = [];
-        const imports = [];
-  
-        traverse(ast, {
-          ClassDeclaration: (nodePath) => this._addNodeData(nodePath.node, file,
-            srcDirPath, functions, imports, genImports, genExports),
-        });
-  
-        if (fs.existsSync(this.options.outputPath)) { 
-          const content = fs.readFileSync(this.options.outputPath, 'utf-8');
-          const output = content ? this._insertImports(content, imports) : imports.join('\n');
-          fs.writeFileSync(this.options.outputPath, output, 'utf-8');
-        } else 
-          fs.writeFileSync(this.options.outputPath, imports.join('\n'), 'utf-8');
-        
-  
-        fs.appendFileSync(this.options.outputPath, functions.join('\n'), 'utf-8');
+        let imports = new Set();
+
+        const fileName = path.basename(file);
+        if(fileName === 'package-functions.ts')
+          imports = new Set([... this._readImports(content)]);
+
+        this._walk(ast, (node, parentClass) => {
+          const decorators = node.decorators;
+          if (!decorators || decorators.length === 0) return;
+
+          if (node?.type === "ClassDeclaration") 
+            this._addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports);
+
+          if (node?.type === "MethodDefinition")
+            this._addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports, parentClass);
+          });
+        this._insertImports([...imports]);
+        fs.appendFileSync(this.options.outputPath, functions.join("\n"), "utf-8");
       }
 
       this._writeToPackageFile(packageFilePath, genImports, genExports);
     });
   }
 
+  _addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports, parent = undefined) {
+    if (!node.decorators || !node.decorators.length || node.decorators?.length === 0)
+      return;
+
+    function modifyImportPath(dirPath, filePath) {
+      const relativePath = path.relative(dirPath, filePath);
+      return `./${relativePath.slice(0, relativePath.length - 3).replace(/\\/g, '/')}`;
+    }
+
+    const decorator =  node.decorators[0];
+    const exp  = decorator.expression;
+    const name = exp.callee?.property?.name || exp.callee?.name;
+    const identifierName = node.id?.name || node.key?.name;
+    const className = parent?.id?.name || parent?.key?.name;
+
+    if (!name) return;
+
+    const decoratorOptions = this._readDecoratorOptions(exp.arguments[0].properties);
+    decoratorOptions.set('tags', [...(reservedDecorators[name]['metadata']['tags'] ?? [] ), ...(decoratorOptions.get('tags') ?? [])])
+    const functionParams = node?.type === 'MethodDefinition' ? this._readMethodParamas(node) : [];
+
+    const annotationByReturnType = node?.type === 'MethodDefinition' ? this._readFunctionReturnTypeInfo(node) : '';
+    const annotationByReturnTypeObj = { name: 'result', type: annotationByReturnType };
+    
+    let importString = generateImport(node?.type === 'MethodDefinition' ? className : identifierName, modifyImportPath(path.dirname(this.options.outputPath), file));
+    imports.add(importString);
+    const funcName = `_${identifierName}`;
+    const funcAnnotaionOptions = {
+      ...reservedDecorators[name]['metadata'],
+      ...(annotationByReturnType ? {outputs: [annotationByReturnTypeObj ?? {}]} : {}),
+      ...Object.fromEntries(decoratorOptions),
+      ...{inputs: functionParams},
+    };    
+
+    functions.push(reservedDecorators[name]['genFunc'](getFuncAnnotation(funcAnnotaionOptions), identifierName,'\n', (className ?? ''), functionParams));
+
+    genImports.push(generateImport(funcName, modifyImportPath(srcDirPath, this.options.outputPath)));
+    genExports.push(generateExport(funcName));
+  }
+
+  _readImports (content) {
+    const importRegex = /(import(?:[\s\w{},*]+from\s*)?['"]([^'"]+)['"];)/g;
+    const results = [];
+  
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      results.push(`${match[1]}\n`);
+    }
+    return results;
+  }
+
+  _readDecoratorOptions(properties){
+    const resultMap = new Map();
+
+    for(let prop of properties)
+      resultMap.set(prop.key.name, this._evalLiteral(prop.value));
+
+    return resultMap;
+  }
+
+  _evalLiteral(node) {
+    if (!node) return null;
+
+    switch (node.type) {
+      case 'Literal':
+        return node.value;
+
+      case 'ArrayExpression':
+        return node.elements.map(el => this._evalLiteral(el));
+
+      case 'ObjectExpression':
+        return Object.fromEntries(
+          node.properties.map(p => {
+            return [p.key.name || p.key.value, this._evalLiteral(p.value)];
+          })
+        );
+
+      default:
+        return '';
+    }
+  }
+
+  _readMethodParamas(node) {
+    const params = node?.value?.params?.map(param => {
+      let baseParam = param.type === 'TSNonNullExpression' ? param.expression : param;
+      let defaultValue = undefined;
+      const options   = param.decorators?.length > 0?  Object.fromEntries(this._readDecoratorOptions(param.decorators[0]?.expression?.arguments[0].properties)) : undefined;
+      
+      if(baseParam.type === 'AssignmentPattern')
+      {
+        if (baseParam?.right?.type  === 'Literal')
+          defaultValue = baseParam?.right?.raw;
+        baseParam = baseParam?.left;
+      } 
+
+      if (baseParam.type === 'RestElement' || baseParam.type === 'Identifier') {
+        let name =
+          baseParam.type === 'RestElement'
+            ? `...${baseParam.argument.name}`
+            : baseParam.name;
+    
+        if (baseParam?.argument?.typeAnnotation)
+          name += ': ' + generate(baseParam.argument.typeAnnotation.typeAnnotation).code;
+    
+        let type = '';
+        if (baseParam?.typeAnnotation)
+          type = generate(baseParam.typeAnnotation.typeAnnotation).code;
+        else
+          type = 'any';
+    
+        return { name: name, type: type, defaultValue: defaultValue, options: options };
+      }
+      else if (baseParam.type === 'ObjectPattern' || baseParam.type === 'ArrayPattern') {
+        let name = '';
+        if (baseParam.type === 'ObjectPattern') {
+          const properties = baseParam.properties.map(prop => {
+            if (prop.type === 'Property' && prop.key.type === 'Identifier')
+              return prop.key.name;
+            else if (prop.type === 'RestElement' && prop.argument.type === 'Identifier')
+              return `...${prop.argument.name}`;
+            else
+              return generate(prop).code;
+          });
+          name = `{ ${properties.join(', ')} }`;
+        } else {
+          const elements = baseParam.elements.map(elem => {
+            if (elem) {
+              if (elem.type === 'Identifier')
+                return elem.name;
+              else
+                return generate(elem).code;
+            } else return '';
+          });
+          name = `[${elements.join(', ')}]`;
+        }
+    
+        let type = '';
+        if (baseParam.typeAnnotation)
+          type = generate(baseParam.typeAnnotation.typeAnnotation).code;
+        else
+          type = 'any';
+
+        return { name: name, type: type, defaultValue: defaultValue, options: options };
+      }
+      return { name: 'value', type: 'any', options: undefined };
+    });
+    return params;
+  }
+
   _getTsFiles(root) {
     const tsFiles = [];
     const extPattern = /\.tsx?$/;
-    const excludedFiles = ['package.ts', 'package-test.ts', 'package.g.ts'];
+    const excludedFiles = ["package.ts", "package-test.ts", "package.g.ts"];
 
     function findFiles(dir) {
       const files = fs.readdirSync(dir);
       for (const file of files) {
         const fullPath = path.join(dir, file);
-        if (fs.statSync(fullPath).isDirectory()) 
-          findFiles(fullPath);
-        else if (extPattern.test(file) && !excludedFiles.includes(file)) 
+        if (fs.statSync(fullPath).isDirectory()) findFiles(fullPath);
+        else if (extPattern.test(file) && !excludedFiles.includes(file))
           tsFiles.push(fullPath);
-        
       }
     }
 
@@ -77,70 +235,112 @@ class FuncGeneratorPlugin {
     return tsFiles;
   }
 
+  _walk(node, visitor, parent = null) {
+    if (!node || typeof node !== "object") return;
+  
+    visitor(node, parent);
+  
+    for (const key in node) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        value.forEach((child) => {
+          if (child && typeof child.type === "string") {
+            this._walk(child, visitor, node.type === 'ClassDeclaration'? node : parent );
+          }
+        });
+      } else if (value && typeof value.type === "string") {
+        this._walk(value, visitor, node.type === 'ClassDeclaration'? node : parent );
+      }
+    }
+  }
+
+  _readFunctionReturnTypeInfo(node) { 
+    let resultType = 'any';
+    let isArray = false;
+    const annotation = node.value.returnType.typeAnnotation;
+    if (annotation?.typeName?.name === 'Promise')
+    {
+      const argumnets = annotation.typeArguments?.params;
+      if (argumnets && argumnets.length===1)
+      {
+        if (argumnets[0].typeName)
+          resultType = argumnets[0].typeName?.right?.name ?? argumnets[0].typeName?.name;
+        else if (argumnets[0].type !== 'TSArrayType')
+          resultType = this._getTypeNameFromNode(argumnets[0]);
+        else if (argumnets[0].elementType.type !== 'TSTypeReference'){
+          isArray = true;
+          resultType = this._getTypeNameFromNode(argumnets[0]?.elementType);
+        }
+        else{
+          isArray = true;
+          resultType = argumnets[0].elementType?.typeName?.name || argumnets[0].elementType?.typeName?.right?.name;
+        }
+      }
+    }    
+    else{      
+      if (annotation.type === 'TSTypeReference')
+        resultType = annotation.typeName?.right?.name ?? annotation.typeName?.name;
+      else if (annotation.type !== 'TSArrayType')
+        resultType = this._getTypeNameFromNode(annotation);
+      else if  (annotation.elementType.type !== 'TSTypeReference'){
+        isArray = true;
+        resultType = this._getTypeNameFromNode(annotation?.elementType);
+      }
+      else{
+        isArray = true;
+        resultType = (annotation?.elementType?.typeName?.name || annotation?.elementType?.typeName?.right?.name);
+      }
+    }
+    
+    resultType = typesToAnnotation[resultType];
+    if (isArray && resultType)
+      resultType = `list<${resultType}>`
+    return resultType;
+  }
+
+  _getTypeNameFromNode(typeNode) {
+    if (typeNode.type === 'TSTypeReference') {
+      return typeNode.typeName.name;
+    } else if (typeNode.type === 'TSVoidKeyword') {
+      return 'void';
+    } else if (typeNode.type === 'TSNumberKeyword') {
+      return 'number';
+    } else if (typeNode.type === 'TSStringKeyword') {
+      return 'string';
+    } else if (typeNode.type === 'TSBooleanKeyword') {
+      return 'boolean';
+    } else {
+      return typeNode.type;
+    }
+  }
+
   _clearGeneratedFile() {
-    fs.writeFileSync(this.options.outputPath, '');
+    fs.writeFileSync(this.options.outputPath, baseImport);
   }
 
   _writeToPackageFile(filePath, imports, exports) {
-    if (imports.length !== exports.length)
-      return;
-    let content = fs.readFileSync(filePath, 'utf-8');
+    if (imports.length !== exports.length) return;
+    let content = fs.readFileSync(filePath, "utf-8");
     for (let i = 0; i < imports.length; i++) {
       const importStatement = imports[i];
       const exportStatement = exports[i];
       if (!content.includes(importStatement.trim()))
         content = importStatement + content + exportStatement;
     }
-    fs.writeFileSync(filePath, content, 'utf-8');
-  }
-
-  _addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports) {
-    if (!node.decorators || !node.decorators.length)
-      return;
-
-    function modifyImportPath(dirPath, filePath) {
-      const relativePath = path.relative(dirPath, filePath);
-      return `./${relativePath.slice(0, relativePath.length - 3).replace(/\\/g, '/')}`;
-    }
-
-    for (const decorator of node.decorators) {
-      const exp = decorator.expression;
-      const name = exp.callee.property.name;
-      const options = {};
-      if (name in reservedDecorators) {
-        if (exp.arguments && exp.arguments.length === 1) {
-          const props = exp.arguments[0].properties;
-          for (const prop of props)
-            options[prop.key.name] = prop.value.value;
-        }
-
-        const className = node.id.name;
-        imports.push(generateImport(className, modifyImportPath(path.dirname(this.options.outputPath), file)));
-        const funcName = `_${className}`;
-        functions.push(reservedDecorators[name]['genFunc'](getFuncAnnotation({
-          ...reservedDecorators[name]['metadata'],
-          ...options,
-        }), className));
-
-        genImports.push(generateImport(funcName, modifyImportPath(srcDirPath, this.options.outputPath)));
-        genExports.push(generateExport(funcName));
-      }
-    }
+    fs.writeFileSync(filePath, content, "utf-8");
   }
 
-  _insertImports(content, imports) {
-    const ast = parse(content, {sourceType: 'module', plugins: ['typescript', 'decorators']});
-    let lastImportLoc = null;
-    traverse(ast, {
-      ImportDeclaration(nodePath) {
-        lastImportLoc = nodePath.node.end + 1;
-      },
-    });
-    return lastImportLoc === null ? imports.join('\n') + content :
-      content.slice(0, lastImportLoc) + imports.join('\n') +
-      (content[lastImportLoc] === '\n' ? '' : '\n') +
-      content.slice(lastImportLoc, content.length);
+  _insertImports(importArray) {
+    if (fs.existsSync(this.options.outputPath)) {
+      const content = fs.readFileSync(this.options.outputPath, "utf-8");
+      if (content)
+        importArray.push(content);
+      const output = importArray.join("");
+      fs.writeFileSync(this.options.outputPath, `${output}`, "utf-8");
+    } 
+    else
+      fs.writeFileSync(this.options.outputPath, `${baseImport}\n${importArray.join("")}`, "utf-8");
   }
 }
 
-module.exports = FuncGeneratorPlugin;
+module.exports = FuncGeneratorPlugin;