datagrok-tools 4.14.30 → 4.14.32

package/bin/grok.js

@@ -26,12 +26,10 @@ if (command in commands) {
     if (argv['help']) {
       console.log(help[command]);
       exitWithCode(1);
-    }
-    else if (argv.all && onPackageCommandNames.includes(command)) {
+    } else if (argv.all && onPackageCommandNames.includes(command)) {
       runAllCommand(process.cwd(),
         `grok ${process.argv.slice(2).join(' ')}`.replace('--all', ''), {});
-    }
-    else if (!commands[command](argv)) {
+    } else if (!commands[command](argv)) {
       console.log(help[command]);
       exitWithCode(1);
     }

package/bin/utils/func-generation.js

@@ -20,7 +20,7 @@ let pseudoParams = exports.pseudoParams = /*#__PURE__*/function (pseudoParams) {
   pseudoParams["INPUT_TYPE"] = "inputType";
   return pseudoParams;
 }({});
-const nonMetaData = ['sidebar', 'editor', 'friendlyName', 'helpUrl'];
+const nonMetaData = ['sidebar', 'editor', 'friendlyName', 'helpUrl', 'condition', 'top-menu', 'cache', 'cache.invalidateOn'];
 const decoratorOptionToAnnotation = new Map([['initialValue', 'default']]);
 const dgAnnotationTypes = exports.dgAnnotationTypes = {
   INT: 'int',
@@ -145,17 +145,23 @@ function getFuncAnnotation(data, comment = '//', sep = '\n') {
     } else type = 'dynamic';
     const options = input?.options?.options ? buildStringOfOptions(input.options.options ?? {}) : '';
     const functionName = (input.options?.name ? input?.options?.name : ` ${input.name?.replaceAll('.', '')}`)?.trim();
+
+    // eslint-disable-next-line max-len
     s += comment + 'input: ' + type + ' ' + functionName + (input.defaultValue !== undefined ? `= ${input.defaultValue}` : '') + ' ' + options.replaceAll('"', '\'') + sep;
   }
   if (data.outputs) {
     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 (output.type !== 'void') {
+        // eslint-disable-next-line max-len
+        s += comment + 'output: ' + output.type + (output.name ? ` ${output.name}${output.options ? ` ${buildStringOfOptions(output.options)}` : ''}` : '') + sep;
+      }
     }
   }
   if (data.meta) {
     for (const entry of Object.entries(data.meta)) s += `${comment}meta.${entry[0]}: ${entry[1]}${sep}`;
   }
   for (const parameter in data) {
+    // eslint-disable-next-line max-len
     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}`;
@@ -431,8 +437,11 @@ const primitives = new Set(['string', 'string[]', 'number', 'number[]', 'boolean
 
 /** Generates a DG function. */
 function generateFunc(annotation, funcName, sep = '\n', className = '', inputs = [], isAsync = false) {
+  // eslint-disable-next-line max-len
   const funcSigNature = inputs.map(e => `${e.name}: ${primitives.has(e.type ?? '') && !typesToAny.includes(e.type ?? '') ? e.type : typesToAnnotation[e.type?.replace('[]', '') ?? ''] && !typesToAny.includes(e.type ?? '') ? e.type : 'any'}`).join(', ');
   const funcArguments = inputs.map(e => e.name).join(', ');
+
+  // eslint-disable-next-line max-len
   return sep + annotation + `export ${isAsync ? 'async ' : ''}function ${funcName}(${funcSigNature}) {${sep}  return ${className.length > 0 ? `${className}.` : ''}${funcName}(${funcArguments});${sep}}${sep}`;
 }
 function generateImport(className, path, sep = '\n') {

package/package-template/package.json

@@ -4,13 +4,13 @@
   "version": "0.0.1",
   "description": "",
   "dependencies": {
-    "datagrok-api": "^1.21.3",
+    "datagrok-api": "^1.26.0",
     "cash-dom": "^8.1.5",
     "dayjs": "^1.11.13",
-    "@datagrok-libraries/utils": "^4.5.7"
+    "@datagrok-libraries/utils": "^4.6.0"
   },
   "devDependencies": {
-    "datagrok-tools": "^4.14.20",
+    "datagrok-tools": "^4.14.32",
     "webpack": "^5.95.0",
     "webpack-cli": "^5.1.4"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "4.14.30",
+  "version": "4.14.32",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {

package/plugins/func-gen-plugin.js

@@ -1,8 +1,8 @@
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs');
+const path = require('path');
 
-const tsParser = require("@typescript-eslint/typescript-estree");
-const generate = require("@babel/generator").default;
+const tsParser = require('@typescript-eslint/typescript-estree');
+const generate = require('@babel/generator').default;
 
 const {
   reservedDecorators,
@@ -11,48 +11,49 @@ const {
   generateExport,
   typesToAnnotation,
   dgAnnotationTypes,
-} = require("../bin/utils/func-generation");
+} = require('../bin/utils/func-generation');
 
-const baseImport = "import * as DG from 'datagrok-api/dg';\n";
+const baseImport = 'import * as DG from \'datagrok-api/dg\';\n';
+// eslint-disable-next-line max-len
 const annotationForGeneratedFile = `/**\nThis file is auto-generated by the webpack command.\nIf you notice any changes, please push them to the repository.\nDo not edit this file manually.\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");
+    const srcDirPath = path.join(compiler.context, 'src');
+    let packageFilePath = path.join(srcDirPath, 'package.ts');
     if (!fs.existsSync(packageFilePath))
-      packageFilePath = path.join(srcDirPath, "package.js");
+      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.includes("@grok.decorators.")) continue;
+        const content = fs.readFileSync(file, 'utf-8');
+        if (!content.includes('@grok.decorators.')) continue;
 
         if (!content) continue;
         const ast = tsParser.parse(content, {
-          sourceType: "module",
+          sourceType: 'module',
           plugins: [
-            ["decorators", { decoratorsBeforeExport: true }],
-            "classProperties",
-            "typescript",
+            ['decorators', {decoratorsBeforeExport: true}],
+            'classProperties',
+            'typescript',
           ],
         });
         const functions = [];
-        let imports = new Set();
+        const imports = new Set();
         this._walk(ast, (node, parentClass) => {
           const decorators = node.decorators;
           if (!decorators || decorators.length === 0) return;
 
-          if (node?.type === "ClassDeclaration")
+          if (node?.type === 'ClassDeclaration') {
             this._addNodeData(
               node,
               file,
@@ -60,10 +61,11 @@ class FuncGeneratorPlugin {
               functions,
               imports,
               genImports,
-              genExports
+              genExports,
             );
+          }
 
-          if (node?.type === "MethodDefinition")
+          if (node?.type === 'MethodDefinition') {
             this._addNodeData(
               node,
               file,
@@ -72,11 +74,12 @@ class FuncGeneratorPlugin {
               imports,
               genImports,
               genExports,
-              parentClass
+              parentClass,
             );
+          }
         });
         this._insertImports([...imports]);
-        fs.appendFileSync(this.options.outputPath, functions.join(""), "utf-8");
+        fs.appendFileSync(this.options.outputPath, functions.join(''), 'utf-8');
       }
       this._checkPackageFileForDecoratorsExport(packageFilePath);
       // Uncommment to add obvious import/export
@@ -92,7 +95,7 @@ class FuncGeneratorPlugin {
     imports,
     genImports,
     genExports,
-    parent = undefined
+    parent = undefined,
   ) {
     if (
       !node.decorators ||
@@ -105,7 +108,7 @@ class FuncGeneratorPlugin {
       const relativePath = path.relative(dirPath, filePath);
       return `./${relativePath
         .slice(0, relativePath.length - 3)
-        .replace(/\\/g, "/")}`;
+        .replace(/\\/g, '/')}`;
     }
 
     const decorator = node.decorators[0];
@@ -117,57 +120,57 @@ class FuncGeneratorPlugin {
     if (!name) return;
 
     const decoratorOptions = this._readDecoratorOptions(
-      exp.arguments[0].properties
+      exp.arguments[0]?.properties ?? [],
     );
 
-    decoratorOptions.set("tags", [
-      ...(reservedDecorators[name]["metadata"]["tags"] ?? []),
-      ...(decoratorOptions.get("tags") ?? []),
+    decoratorOptions.set('tags', [
+      ...(reservedDecorators[name]['metadata']['tags'] ?? []),
+      ...(decoratorOptions.get('tags') ?? []),
     ]);
     const functionParams =
-      node?.type === "MethodDefinition" ? this._readMethodParamas(node) : [];
-    const annotationByReturnObj = node?.type === "MethodDefinition" ? this._readOutputsFromReturnType(node) : undefined;
+      node?.type === 'MethodDefinition' ? this._readMethodParamas(node) : [];
+    const annotationByReturnObj = node?.type === 'MethodDefinition' ? this._readOutputsFromReturnType(node) : undefined;
     const isMethodAsync = this._isMethodAsync(node);
-    let importString = generateImport(
-      node?.type === "MethodDefinition" ? className : identifierName,
-      modifyImportPath(path.dirname(this.options.outputPath), file)
+    const importString = generateImport(
+      node?.type === 'MethodDefinition' ? className : identifierName,
+      modifyImportPath(path.dirname(this.options.outputPath), file),
     );
     imports.add(importString);
     const funcName = `${
-      node?.type === "MethodDefinition" ? "" : "_"
+      node?.type === 'MethodDefinition' ? '' : '_'
     }${identifierName}`;
     const funcAnnotaionOptions = {
-      ...reservedDecorators[name]["metadata"],
-      ...(annotationByReturnObj
-        ? { outputs: annotationByReturnObj ?? [] }
-        : {}),
+      ...reservedDecorators[name]['metadata'],
+      ...(annotationByReturnObj ?
+        {outputs: annotationByReturnObj ?? []} :
+        {}),
       ...Object.fromEntries(decoratorOptions),
-      ...{ inputs: functionParams },
-      ...{ isAsync: isMethodAsync },
+      ...{inputs: functionParams},
+      ...{isAsync: isMethodAsync},
     };
     if (!funcAnnotaionOptions.name) funcAnnotaionOptions.name = identifierName;
     functions.push(
-      reservedDecorators[name]["genFunc"](
+      reservedDecorators[name]['genFunc'](
         getFuncAnnotation(funcAnnotaionOptions),
         identifierName,
-        "\n",
-        className ?? "",
+        '\n',
+        className ?? '',
         functionParams,
-        funcAnnotaionOptions.isAsync ?? false
-      )
+        funcAnnotaionOptions.isAsync ?? false,
+      ),
     );
     genImports.push(
       generateImport(
         funcName,
-        modifyImportPath(srcDirPath, this.options.outputPath)
-      )
+        modifyImportPath(srcDirPath, this.options.outputPath),
+      ),
     );
     genExports.push(generateExport(funcName));
   }
 
   _isMethodAsync(node) {
     let result = false;
-    if (node.type === "MethodDefinition") result = node.value.async;
+    if (node.type === 'MethodDefinition') result = node.value.async;
     return result;
   }
 
@@ -176,86 +179,87 @@ class FuncGeneratorPlugin {
     const results = [];
 
     let match;
-    while ((match = importRegex.exec(content)) !== null) {
+    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));
+    for (const prop of properties)
+      resultMap.set(prop.key.name ?? prop.key.value, this._evalLiteral(prop.value));
     return resultMap;
   }
 
   _evalLiteral(node) {
     if (!node) return null;
     switch (node.type) {
-      case "Literal":
-        return node.value;
+    case 'Literal':
+      return node.value;
 
-      case "ArrayExpression":
-        return node.elements.map((el) => this._evalLiteral(el));
+    case 'ArrayExpression':
+      return node.elements.map((el) => this._evalLiteral(el));
 
-      case "MemberExpression":
-        return dgAnnotationTypes[node?.property?.name ?? ""] ?? "dynamic";
+    case 'MemberExpression':
+      return dgAnnotationTypes[node?.property?.name ?? ''] ?? 'dynamic';
 
-      case "ObjectExpression":
-        return Object.fromEntries(
-          node.properties.map((p) => {
-            return [p.key.name || p.key.value, this._evalLiteral(p.value)];
-          })
-        );
+    case 'ObjectExpression':
+      return Object.fromEntries(
+        node.properties.map((p) => {
+          return [p.key.name || p.key.value, this._evalLiteral(p.value)];
+        }),
+      );
 
-      default:
-        return "";
+    default:
+      return '';
     }
   }
 
   _readMethodParamas(node) {
     const params = node?.value?.params?.map((param) => {
       let baseParam =
-        param.type === "TSNonNullExpression" ? param.expression : param;
+        param.type === 'TSNonNullExpression' ? param.expression : param;
       const options =
-        param.decorators?.length > 0
-          ? Object.fromEntries(
-              this._readDecoratorOptions(
-                param.decorators[0]?.expression?.arguments[0].properties
-              )
-            )
-          : undefined;
+        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.type === 'AssignmentPattern') {
         // if (baseParam?.right?.type  === 'Literal')
         //   defaultValue = baseParam?.right?.raw;
         baseParam = baseParam?.left;
       }
 
-      if (baseParam.type === "RestElement" || baseParam.type === "Identifier") {
+      if (baseParam.type === 'RestElement' || baseParam.type === 'Identifier') {
         let name =
-          baseParam.type === "RestElement"
-            ? `...${baseParam.argument.name}`
-            : baseParam.name;
-        if (baseParam?.argument?.typeAnnotation)
+          baseParam.type === 'RestElement' ?
+            `...${baseParam.argument.name}` :
+            baseParam.name;
+        if (baseParam?.argument?.typeAnnotation) {
           name +=
-            ": " +
+            ': ' +
             generate(baseParam.argument.typeAnnotation.typeAnnotation).code;
+        }
 
-        let type = "";
+        let type = '';
         if (baseParam?.typeAnnotation?.typeAnnotation)
           type = generate(baseParam.typeAnnotation.typeAnnotation).code;
-        else type = "any";
+        else type = 'any';
 
-        let params =
+        const params =
           baseParam.typeAnnotation.typeAnnotation.typeArguments?.params;
-        if (type !== "any" && params && params.length > 0)
-          type += `<${params.map((e) => e.typeName?.name ?? 'any').join(",")}>`;
+        if (type !== 'any' && params && params.length > 0)
+          type += `<${params.map((e) => e.typeName?.name ?? 'any').join(',')}>`;
 
-        return { name: name, type: type, options: options };
+        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') {
@@ -290,7 +294,7 @@ class FuncGeneratorPlugin {
 
       //   return { name: name, type: type, options: options };
       // }
-      return { name: "value", type: "any", options: undefined };
+      return {name: 'value', type: 'any', options: undefined};
     });
     return params;
   }
@@ -298,7 +302,7 @@ class FuncGeneratorPlugin {
   _getTsFiles(root) {
     const tsFiles = [];
     const extPattern = /\.tsx?$/;
-    const excludedFiles = ["package-test.ts", "package.g.ts"];
+    const excludedFiles = ['package-test.ts', 'package.g.ts'];
 
     function findFiles(dir) {
       const files = fs.readdirSync(dir);
@@ -315,7 +319,7 @@ class FuncGeneratorPlugin {
   }
 
   _walk(node, visitor, parent = null) {
-    if (!node || typeof node !== "object") return;
+    if (!node || typeof node !== 'object') return;
 
     visitor(node, parent);
 
@@ -323,40 +327,39 @@ class FuncGeneratorPlugin {
       const value = node[key];
       if (Array.isArray(value)) {
         value.forEach((child) => {
-          if (child && typeof child.type === "string") {
+          if (child && typeof child.type === 'string') {
             this._walk(
               child,
               visitor,
-              node.type === "ClassDeclaration" ? node : parent
+              node.type === 'ClassDeclaration' ? node : parent,
             );
           }
         });
-      } else if (value && typeof value.type === "string") {
+      } else if (value && typeof value.type === 'string') {
         this._walk(
           value,
           visitor,
-          node.type === "ClassDeclaration" ? node : parent
+          node.type === 'ClassDeclaration' ? node : parent,
         );
       }
     }
   }
 
   _readReturnType(annotation) {
-    let resultType = "dynamic";
+    let resultType = 'dynamic';
     let isArray = false; 
     if (
       annotation &&
-      annotation.type !== "TSUnionType" &&
-      annotation.type !== "TSIntersectionType"
+      annotation.type !== 'TSUnionType' &&
+      annotation.type !== 'TSIntersectionType'
     ) {
       
-      if (annotation.typeName || annotation.type === "TSTypeReference")
+      if (annotation.typeName || annotation.type === 'TSTypeReference') {
         resultType =
           annotation.typeName?.right?.name ?? annotation.typeName?.name;
-      else if (annotation.type !== "TSArrayType"){
+      } else if (annotation.type !== 'TSArrayType') 
         resultType = this._getTypeNameFromNode(annotation);
-      }
-      else if (annotation.elementType.type !== "TSTypeReference") {
+      else if (annotation.elementType.type !== 'TSTypeReference') {
         isArray = true;
         resultType = this._getTypeNameFromNode(annotation?.elementType);
       } else {
@@ -378,18 +381,17 @@ class FuncGeneratorPlugin {
     if (node?.type === 'ClassDeclaration')
       return [];
     
-    if (annotation?.typeName?.name === "Promise") {
+    if (annotation?.typeName?.name === 'Promise') {
       const argumnets = annotation.typeArguments?.params;
-      if (argumnets && argumnets.length === 1) {
+      if (argumnets && argumnets.length === 1) 
         annotation = argumnets[0];
-      } else annotation = {};
+      else annotation = {};
     }
 
-    if (annotation?.type === "TSTypeLiteral"){
+    if (annotation?.type === 'TSTypeLiteral') 
       results = this._readOutputsFromReturnTypeObject(annotation);
-    }
-    else{
-      let resultType = this._readReturnType(annotation);
+    else {
+      const resultType = this._readReturnType(annotation);
       results.push({name: 'result', type: resultType});
       if (resultType === 'void')
         results = [];
@@ -399,8 +401,8 @@ class FuncGeneratorPlugin {
 
   _readOutputsFromReturnTypeObject(node) {
     let i = 0;
-    let results = [];
-    for (let member of node.members) {
+    const results = [];
+    for (const member of node.members) {
       results.push({
         name: member?.key?.name ?? `result${i}`,
         type: this._readReturnType(member.typeAnnotation.typeAnnotation),
@@ -411,19 +413,19 @@ class FuncGeneratorPlugin {
   }
 
   _getTypeNameFromNode(typeNode) {
-    if (typeNode.type === "TSTypeReference") {
+    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 {
+    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() {
@@ -431,38 +433,41 @@ class FuncGeneratorPlugin {
   }
 
   _checkPackageFileForDecoratorsExport(packagePath) {
-    const content = fs.readFileSync(packagePath, "utf-8");
+    const content = fs.readFileSync(packagePath, 'utf-8');
     const decoratorsExportRegex = /export\s*\*\s*from\s*'\.\/package\.g';/;
-    if (!decoratorsExportRegex.test(content))
+    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`
+        // eslint-disable-next-line max-len
+        `\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`,
       );
+    }
   }
 
   _writeToPackageFile(filePath, imports, exp) {
     if (imports.length !== exp.length) return;
-    let content = fs.readFileSync(filePath, "utf-8");
+    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 = annotationForGeneratedFile + importStatement + content + exportStatement;
     }
-    fs.writeFileSync(filePath, content, "utf-8");
+    fs.writeFileSync(filePath, content, 'utf-8');
   }
 
   _insertImports(importArray) {
     if (fs.existsSync(this.options.outputPath)) {
-      const content = fs.readFileSync(this.options.outputPath, "utf-8");
+      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
+      const output = importArray.join('');
+      fs.writeFileSync(this.options.outputPath, `${output}`, 'utf-8');
+    } else {
       fs.writeFileSync(
         this.options.outputPath,
-        `${annotationForGeneratedFile}${baseImport}\n${importArray.join("")}`,
-        "utf-8"
+        `${annotationForGeneratedFile}${baseImport}\n${importArray.join('')}`,
+        'utf-8',
       );
+    }
   }
 }