datagrok-tools 4.13.78 → 4.14.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Datagrok-tools changelog
 
+## 4.14.0 (2025-05-12)
+
+### Features
+
+* Added annotation creation by decorators
+
 ## 4.13.70 (2025-04-14)
 
 ### Features

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 */
 
@@ -20,42 +20,117 @@ let pseudoParams = exports.pseudoParams = /*#__PURE__*/function (pseudoParams) {
   pseudoParams["INPUT_TYPE"] = "inputType";
   return pseudoParams;
 }({});
+const nonMetaData = ['sidebar', 'editor'];
+const decoratorOptionToAnnotation = new Map([['initialValue', 'default']]);
 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";
+  FUNC_TYPES["FILE_HANDLER"] = "file-handler";
   FUNC_TYPES["FILE_VIEWER"] = "fileViewer";
   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";
+  FUNC_TYPES["MODEL"] = "model";
   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',
+  'void': 'void',
+  'string': 'string'
+};
+
 /** 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;
-  const isFileImporter = data.tags?.includes(FUNC_TYPES.FILE_IMPORTER) ?? false;
+  const isFileImporter = data.tags?.includes(FUNC_TYPES.FILE_HANDLER) ?? false;
   let s = '';
   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}`;
+  if (data.tags && data.tags?.length > 0) {
+    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';
+    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;
+    for (const output of data.outputs) if (output.type !== 'void') s += comment + 'output: ' + output.type + (output.name ? ` ${output.name}${output.options ? ` ${buildStringOfOptions(output.options)}` : ''}` : '') + 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' || parameter === 'isAsync' || parameter === 'test') 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}`;
+    } else if (!headerParams.includes(parameter)) {
+      if (nonMetaData.includes(parameter)) s += `${comment}${parameter}: ${data[parameter]}${sep}`;else s += `${comment}meta.${parameter}: ${data[parameter]}${sep}`;
+    }
+  }
+  if (data.test) {
+    for (let entry of Object.entries(data.test)) {
+      if (entry[0] === 'test' || entry[0] === 'wait') s += `${comment}`;else s += `, `;
+      s += `${entry[0]}: ${entry[1]} `;
+    }
+    s += `${sep}`;
   }
   return s;
 }
+function buildStringOfOptions(options) {
+  let optionsInString = [];
+  for (const [key, value] of Object.entries(options ?? {})) {
+    let val = value;
+    let option = key;
+    option = decoratorOptionToAnnotation.get(option) ?? option;
+    if (Array.isArray(value)) val = JSON.stringify(value);
+    optionsInString.push(`${option}: ${val}`);
+  }
+  return `{ ${optionsInString.join('; ')} }`;
+}
 const reservedDecorators = exports.reservedDecorators = {
   viewer: {
     metadata: {
@@ -98,9 +173,9 @@ const reservedDecorators = exports.reservedDecorators = {
     },
     genFunc: generateFunc
   },
-  fileImporter: {
+  fileHandler: {
     metadata: {
-      tags: [FUNC_TYPES.FILE_IMPORTER],
+      tags: [FUNC_TYPES.FILE_HANDLER],
       inputs: [{
         name: 'content',
         type: 'string'
@@ -136,6 +211,163 @@ 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
+  },
+  demo: {
+    metadata: {
+      tags: [],
+      inputs: [],
+      outputs: []
+    },
+    genFunc: generateFunc
+  },
+  treeBrowser: {
+    metadata: {
+      tags: [],
+      inputs: [{
+        name: 'treeNode',
+        type: 'dynamic'
+      }, {
+        name: 'browseView',
+        type: 'view'
+      }],
+      outputs: []
+    },
+    genFunc: generateFunc
+  },
+  model: {
+    metadata: {
+      tags: [FUNC_TYPES.MODEL],
+      inputs: [],
+      outputs: []
+    },
+    genFunc: generateFunc
   }
 };
 
@@ -145,8 +377,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 = [], isAsync = false) {
+  let funcSigNature = inputs.map(e => `${e.name}: ${e.type}`).join(', ');
+  let funcArguments = inputs.map(e => e.name).join(', ');
+  return annotation + `export ${isAsync ? 'async ' : ''}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/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.78",
+  "version": "4.14.0",
   "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",

package/plugins/func-gen-plugin.js

@@ -1,75 +1,243 @@
-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 = '\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)
+        const content = fs.readFileSync(file, "utf-8");
+        if(!content.includes('@grok.decorators.'))
           continue;
-        const ast = parse(content, {
-          sourceType: 'module',
-          plugins: ['typescript', [
-            'decorators',
-            {decoratorsBeforeExport: true},
-          ]],
+        
+        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),
+        let imports = new Set();
+        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(""), "utf-8");
+      }
+      this._checkPackageFileForDecoratorsExport(packageFilePath);
+      // Uncommment to add obvious import/export 
+      // 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 };
+    const isMethodAsync = this._isMethodAsync(node);
+    let importString = generateImport(node?.type === 'MethodDefinition' ? className : identifierName, modifyImportPath(path.dirname(this.options.outputPath), file));
+    imports.add(importString);
+    const funcName = `${node?.type === 'MethodDefinition' ? '' : '_'}${identifierName}`;
+    const funcAnnotaionOptions = {
+      ...reservedDecorators[name]['metadata'],
+      ...(annotationByReturnType ? {outputs: [annotationByReturnTypeObj ?? {}]} : {}),
+      ...Object.fromEntries(decoratorOptions),
+      ...{inputs: functionParams},
+      ...{isAsync: isMethodAsync}
+    };    
+    if (!funcAnnotaionOptions.name)
+      funcAnnotaionOptions.name = identifierName;
+    functions.push(reservedDecorators[name]['genFunc'](getFuncAnnotation(funcAnnotaionOptions), identifierName,'\n', (className ?? ''), functionParams, funcAnnotaionOptions.isAsync ?? false));
+    genImports.push(generateImport(funcName, modifyImportPath(srcDirPath, this.options.outputPath)));
+    genExports.push(generateExport(funcName));
+  }
+
+  _isMethodAsync(node){
+    let result = false;
+    if (node.type === 'MethodDefinition')
+      result = node.value.async;
+    return result;
+  }
+
+  _readImports (content) {
+    const importRegex = /(import(?:[\s\w{},*]+from\s*)?['"]([^'"]+)['"];)/g;
+    const results = [];
   
-        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 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;
+      const options   = param.decorators?.length > 0?  Object.fromEntries(this._readDecoratorOptions(param.decorators[0]?.expression?.arguments[0].properties)) : undefined;
+      
+      // Commented code finds value by default of function's variable  
+      // let defaultValue = 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?.typeAnnotation?.typeName || baseParam?.typeAnnotation?.typeAnnotation?.elementType?.typeName)
+          type = 'any';
+        else if (baseParam?.typeAnnotation?.typeAnnotation)
+          type = generate(baseParam.typeAnnotation.typeAnnotation).code;
+        let params = baseParam.typeAnnotation.typeAnnotation.typeArguments?.params;
+        if(type !== 'any' && params && params.length > 0)
+          type += `<${params.map((e)=>e.typeName.name).join(',')}>`;
+        return { name: name, type: type, options: options };
       }
+      // Commented code belove sets more strong types for ObjectPatterns and ArrayPatterns
+      // 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';
 
-      this._writeToPackageFile(packageFilePath, genImports, genExports);
+      //   return { name: name, type: type, 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-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 +245,120 @@ class FuncGeneratorPlugin {
     return tsFiles;
   }
 
-  _clearGeneratedFile() {
-    fs.writeFileSync(this.options.outputPath, '');
-  }
-
-  _writeToPackageFile(filePath, imports, exports) {
-    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;
+  _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 );
+      }
     }
-    fs.writeFileSync(filePath, content, 'utf-8');
   }
 
-  _addNodeData(node, file, srcDirPath, functions, imports, genImports, genExports) {
-    if (!node.decorators || !node.decorators.length)
-      return;
+  _readFunctionReturnTypeInfo(node) { 
+    let resultType = 'any';
+    let isArray = false;
+    const annotation = node.value?.returnType?.typeAnnotation;
+    if (annotation) {
+      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;
+  }
 
-    function modifyImportPath(dirPath, filePath) {
-      const relativePath = path.relative(dirPath, filePath);
-      return `./${relativePath.slice(0, relativePath.length - 3).replace(/\\/g, '/')}`;
+  _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;
     }
+  }
 
-    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;
-        }
+  _clearGeneratedFile() {
+    fs.writeFileSync(this.options.outputPath, baseImport);
+  }
 
-        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));
+  _checkPackageFileForDecoratorsExport(packagePath){    
+    const content = fs.readFileSync(packagePath, "utf-8");
+    const decoratorsExportRegex = /export\s*\*\s*from\s*'\.\/package\.g';/;
+    if (!decoratorsExportRegex.test(content))
+      console.warn(`\nWARNING: Your package doesn't export package.g.ts file to package.ts \n please add "export * from './package.g';" to the package.ts file.\n`);
+  }
 
-        genImports.push(generateImport(funcName, modifyImportPath(srcDirPath, this.options.outputPath)));
-        genExports.push(generateExport(funcName));
-      }
+  _writeToPackageFile(filePath, imports, exp) {
+    if (imports.length !== exp.length) return;
+    let content = fs.readFileSync(filePath, "utf-8");
+    for (let i = 0; i < imports.length; i++) {
+      const importStatement = imports[i];
+      const exportStatement = exp[i];
+      if (!content.includes(importStatement.trim()))
+        content = importStatement + content + exportStatement;
     }
+    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;