@bemoje/cli 0.0.4 → 0.0.6

package/{src → dist/types}/util/validation/isFunction.d.ts

@@ -1,4 +1,4 @@
-import { TFunction } from '../types/TFunction';
+import type { TFunction } from '../types/TFunction';
 /**
  * Checks if the given value is a function.
  *

package/{src → dist/types}/util/validation/isNamedFunction.d.ts

@@ -1,4 +1,4 @@
-import { TFunction } from '../types/TFunction';
+import type { TFunction } from '../types/TFunction';
 /**
  * Checks if the provided value is a named function.
  */

package/{src → dist/types}/util/validation/isPlainObject.d.ts

@@ -1,5 +1,5 @@
-import { ObjectKey } from '../types/ObjectKey';
-import { TPlainObject } from '../types/TPlainObject';
+import type { ObjectKey } from '../types/ObjectKey';
+import type { TPlainObject } from '../types/TPlainObject';
 /**
  * Checks if the provided value is a plain object, i.e. an object created by the native base `Object` constructor.
  */

package/{src → dist/types}/util/validation/isPrimitive.d.ts

@@ -1,4 +1,4 @@
-import { TPrimitive } from '../types/TPrimitive';
+import type { TPrimitive } from '../types/TPrimitive';
 /**
  * Checks if the provided value is a primitive type (null, undefined, bigint, boolean, number, string or symbol).
  * @param value The value to check.

package/jest.config.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+export default {
+  displayName: 'cli',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/packages/cli',
+}

package/notes/tsc.md

@@ -0,0 +1 @@
+npx tsc packages\cli\src\index.ts --outDir packages\cli\dist --module commonjs --lib es2022 --moduleResolution node --downlevelIteration --esModuleInterop --target ES2022 --allowSyntheticDefaultImports --declaration --sourceMap

package/package.json

@@ -1,16 +1,22 @@
 {
   "name": "@bemoje/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
+  "scripts": {
+    "build:cjs": "rimraf dist/cjs && npx tsc src/index.ts --outDir dist/cjs --module commonjs --lib es2022 --moduleResolution node --downlevelIteration --esModuleInterop --target ES2022 --allowSyntheticDefaultImports --moduleResolution node --sourceMap",
+    "build:esm": "rimraf dist/esm && npx tsc src/index.ts --outDir dist/esm --module es2022 --lib es2022 --moduleResolution node --downlevelIteration --esModuleInterop --target ES2022 --allowSyntheticDefaultImports --moduleResolution node --sourceMap",
+    "build:types": "rimraf dist/types && npx tsc src/index.ts --outDir dist/types --module es2022 --lib es2022 --moduleResolution node --downlevelIteration --esModuleInterop --target ES2022 --allowSyntheticDefaultImports --moduleResolution node --declaration --emitDeclarationOnly",
+    "build": "npm run build:cjs && npm run build:esm && npm run build:types"
+  },
   "dependencies": {
+    "@commander-js/extra-typings": "^11.1.0",
     "ansi-colors": "^4.1.3",
     "cli-table": "^0.3.11",
-    "commander": "^11.1.0",
     "fs-extra": "^11.2.0",
     "is-async-function": "^2.0.0"
   },
-  "type": "commonjs",
-  "main": "./index.cjs.js",
-  "module": "./index.esm.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
   "author": {
     "name": "Benjamin Møller Jensen",
     "email": "bemoje@bemoje.net",
@@ -33,6 +39,7 @@
   "devDependencies": {
     "@types/cli-table": "^0.3.4",
     "@types/is-async-function": "^2.0.2",
-    "@types/prompts": "^2.4.9"
+    "@types/prompts": "^2.4.9",
+    "rimraf": "^5.0.5"
   }
 }

package/project.json

@@ -0,0 +1,44 @@
+{
+  "name": "cli",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/cli/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "nx:run-script",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "script": "build",
+        "outputPath": "dist/packages/cli",
+        "main": "packages/cli/src/index.ts",
+        "tsConfig": "packages/cli/tsconfig.lib.json",
+        "assets": [],
+        "project": "packages/cli/package.json",
+        "compiler": "tsc",
+        "format": ["cjs", "esm"]
+      }
+    },
+    "lint": {
+      "executor": "@nx/linter:eslint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["packages/cli/**/*.ts", "packages/cli/package.json"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "packages/cli/jest.config.ts",
+        "passWithNoTests": true
+      },
+      "configurations": {
+        "ci": {
+          "ci": true,
+          "codeCoverage": true
+        }
+      }
+    }
+  },
+  "tags": []
+}

package/scripts/currentBemojeUtils.txt

@@ -0,0 +1,41 @@
+'realizeLazyProperty',
+'JsonValue',
+'TStringParser',
+'arrLast',
+'TValidator',
+'colors',
+'Any',
+'arrAssign',
+'arrSome',
+'assertThat',
+'ensureThat',
+'formatTableForTerminal',
+'isArray',
+'isObject',
+'isString',
+'isStringArray',
+'isStringWithNoSpacesOrDashes',
+'objAssign',
+'removeFile',
+'setNonEnumerable',
+'ErrorParser',
+'TConstructor',
+'MethodDisabler',
+'createTypedListParser',
+'parseInteger',
+'parseNumber',
+'parseString',
+'createTypedArrayValidator',
+'isInteger',
+'isValidNumber',
+'promptUserEditJsonInTextEditorSync',
+'defaultOpenInEditorCommand',
+'JsonDB',
+'strEnsureStartsWith',
+'ObjectKey',
+'execInherit',
+'strSplitCamelCase',
+'isBoolean',
+'parseBoolean',
+'readFileSafeSync',
+'writeFileSafeSync'

package/scripts/rollupUtils.ts

@@ -0,0 +1,184 @@
+import fs from 'fs-extra'
+import path from 'path'
+import walkdir from 'walkdir'
+import { readFileSafeSync } from '../src/util/fs/readFile/readFileSafeSync'
+import { Stats } from 'fs-extra'
+import type { WalkOptions } from 'walkdir'
+
+/**
+ * Extract all import statements from a given TypeScript source code string.
+ * @param code The TypeScript code as a string from which to extract import statements.
+ * @returns An array of objects, each representing an import statement. Each object includes the start and end line numbers (0-indexed) of the import statement in the original code, and the full text of the import statement.
+ */
+function tsExtractImports(code: string): ITsExtractImportsResult[] {
+  code = code.replace(/;/g, '')
+  const isFirstLine = /^import /
+  const isFirstLineInMulti = /\{\s*$/
+  const isLastLineInMulti = /^\} from '/
+  const result: ITsExtractImportsResult[] = []
+  let isMulti = false
+  let impLines = []
+  const lines = code.split(/\r?\n/)
+  for (let l = 0; l < lines.length; l++) {
+    const line = lines[l]
+    if (isFirstLine.test(line)) {
+      if (isFirstLineInMulti.test(line)) {
+        impLines.push(line)
+        isMulti = true
+      } else {
+        result.push({
+          start: l,
+          end: l,
+          match: line,
+        })
+      }
+    } else if (isMulti) {
+      impLines.push(line)
+      if (isLastLineInMulti.test(line)) {
+        result.push({
+          start: l - impLines.length + 1,
+          end: l,
+          match: impLines.join('\n'),
+        })
+        impLines = []
+        isMulti = false
+      }
+    }
+  }
+  return result
+}
+
+interface ITsExtractImportsResult {
+  /**
+   * The line index where the import statement starts.
+   */
+  start: number
+  /**
+   * The line index of the last line of the import statement.
+   */
+  end: number
+  /**
+   * The import statement.
+   */
+  match: string
+}
+
+export function walkTsFiles(
+  srcdir: string,
+  filter: (filepath: string, stat: Stats) => boolean = () => true,
+  options: WalkOptions = {}
+): string[] {
+  const result: string[] = []
+  walkdir.sync(srcdir, options, (filepath, stat) => {
+    if (!stat.isFile()) return
+    if (!/\.ts$/i.test(filepath)) return
+    // if (/\..+\.ts$/i.test(filepath)) return
+    if (!filter(filepath, stat)) return
+    result.push(filepath)
+  })
+  return result
+}
+
+const cliFilepaths = walkTsFiles('packages/cli/src')
+const imports = cliFilepaths
+  .map((filepath) => {
+    const src = readFileSafeSync(filepath)
+    // if(!src) return {filepath, imports: []}
+    const imps = tsExtractImports(src || '')
+      .map((imp) => {
+        const res = imp.match.replace(/\n/g, '').replace(/\s+/g, ' ')
+        if (!res.endsWith("from '@bemoje/util'")) return
+        return res
+          .replace(/^import( type)? \{/, '')
+          .replace("} from '@bemoje/util'", '')
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean)
+      })
+      .flat()
+      .map((s) => s?.trim())
+      .filter(Boolean)
+    return { filepath, imports: imps }
+  })
+  .filter((imp) => imp.imports.length)
+// console.dir(imports, { depth: null })
+const set = new Set(imports.map((imp) => imp.imports).flat())
+console.log(set)
+
+const utilFilepaths = walkTsFiles('packages/util/src')
+
+const filepaths = new Set<string>()
+
+for (const name of set) {
+  const filepath = utilFilepaths.find((filepath) => filepath.endsWith(`${name}.ts`))
+  if (!filepath) {
+    console.log({ fileNonExistent: name })
+    continue
+  }
+  filepaths.add(filepath)
+}
+// console.log(filepaths)
+
+function recurse(filepath: string) {
+  const src = readFileSafeSync(filepath)
+  for (const imp of tsExtractImports(src || '')) {
+    const res = imp.match.replace(/\n/g, '').replace(/\s+/g, ' ')
+    const regex = /from '\.\.?\//g
+    if (!regex.test(res)) continue
+    const relative = res.split(' from ')[1].replace(/['"]/g, '').trim()
+    if (!relative) continue
+    const resolved = path.resolve(path.dirname(filepath), relative + '.ts')
+    // console.log({ relative, resolved })
+    if (filepaths.has(resolved)) continue
+    filepaths.add(resolved)
+    recurse(resolved)
+  }
+}
+
+filepaths.forEach(recurse)
+
+for (const filepath of filepaths) {
+  const testFilepath = filepath.replace(/\.ts$/, '.test.ts')
+  if (fs.existsSync(testFilepath)) {
+    filepaths.add(testFilepath)
+  }
+}
+
+filepaths.forEach(recurse)
+
+filepaths.forEach((filepath) => {
+  filepath = filepath.replace(/\\+/g, '/')
+  const destFilepath = filepath.replace('packages/util/src', 'packages/cli/src/util')
+  // console.log({ filepath, destFilepath })
+  fs.ensureDirSync(path.dirname(destFilepath))
+  fs.copyFileSync(filepath, destFilepath)
+
+  // const src = readFileSafeSync(filepath)
+  // if (!src) {
+  //   console.log({ NO_SOURCE_AT: filepath })
+  //   return
+  // }
+  // for (const imp of tsExtractImports(src || '')) {
+  //   const res = imp.match.replace(/\n/g, '').replace(/\s+/g, ' ')
+  //   const regex = /from '\.\.?\//g
+  //   if (regex.test(res)) continue
+  //   externalImports.add(res)
+  // }
+  // source.push(tsStripImports(src))
+  // const testFilepath = filepath.replace(/\.ts$/, '.test.ts')
+  // if (fs.existsSync(testFilepath)) {
+  //   testsource.push(readFileSync(testFilepath, 'utf8').replace(/from '\..+$/gm, "from './util'"))
+  // }
+})
+
+// source.push([...externalImports].join('\n'))
+// source.reverse()
+// testsource.reverse()
+// const result = source.join('\n\n\n').replace(/^export .+ from .+$/gm, (s) => s.replace('export ', 'import ') + '\n' + s)
+// writeFileSafeSync('packages/cli/src/core/bemoje-util.ts', result)
+// const testresult = testsource.join('\n\n\n')
+// const testresultImports = [
+//   ...new Set(testresult.split('\n').filter((l) => l.startsWith('import ') && l.endsWith("'"))),
+// ].join('\n')
+// const testresultCode = tsStripImports(testresult)
+// writeFileSafeSync('packages/cli/src/core/bemoje-util.test.ts', testresultImports + '\n\n' + testresultCode)

package/src/_example/CommandBuilder.example.ts

@@ -0,0 +1,92 @@
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { isBoolean } from '../util/validation/isBoolean'
+import { parseBoolean } from '../util/string-parsers/parseBoolean'
+
+console.time('load')
+
+const cli = new CommandBuilder('demo', (c) => {
+  c.version('0.0.1')
+  c.description('A CLI example')
+  c.setRecommended()
+  // c.action(() => {})
+
+  c.command('hello', (h) => {
+    h.description('just prints hello')
+    h.argument('[name]')
+    h.action((name?: string) => {
+      console.log('hello ' + name)
+    })
+    h.preset('benja', {
+      description: 'Benjamin',
+      args: ['Benjamin'],
+    })
+    h.preset('thomas', {
+      description: 'Thomas',
+      args: ['Thomas'],
+    })
+  })
+
+  c.command('info', (i) => {
+    i.description('enter info about yourself')
+    i.argument('[name]', (a) => {
+      a.description('Your name')
+    })
+
+    i.argument('[friends]', (a) => {
+      a.description('Comma-delimited list of friends')
+      a.parser.delimitedStrings(',')
+      a.validator.isStringArray()
+    })
+
+    i.argument('[nums...]', (a) => {
+      a.description('Your favorite numbers between 0 and 4')
+      a.choices(['0', '1', '2', '3', '4'])
+      a.parser.integer()
+      a.validator.isIntegerArray()
+    })
+
+    i.option('--age [years]', (o) => {
+      o.description('Your age in years.')
+      o.parser.integer()
+      o.validator.isInteger()
+      o.validator.custom(function isAdult(age: unknown) {
+        return (age as number) >= 18
+      })
+    })
+
+    i.action((name, friends, nums, opts) => {
+      console.log({ name, friends, nums, ...opts })
+    })
+
+    i.config('inSchool', {
+      description: 'whether you are attending school',
+      defaultValue: true,
+      parse: parseBoolean,
+      validate: isBoolean,
+    })
+
+    i.preset('benjabob', {
+      description: 'Benjamin',
+      presets: ['old'],
+      args: ['Benjamin', ['Thomas', 'Lasse']],
+      options: { age: 35 },
+    })
+    i.preset('adult', {
+      description: 'Age is 18',
+      options: { age: 18 },
+    })
+    i.preset('old', {
+      description: 'Age is 35',
+      options: { age: 35 },
+    })
+  })
+
+  c.command('nothing', (n) => {
+    n
+  })
+})
+console.timeEnd('load')
+
+console.time('exec')
+cli.$.parse()
+console.timeEnd('exec')

package/src/_example/CommandBuilder.example2.ts

@@ -0,0 +1,30 @@
+import { CommandBuilder } from '../cmd/CommandBuilder'
+
+console.time('load')
+
+const cli = new CommandBuilder('demo', (c) => {
+  c.version('0.0.1')
+  c.description('A CLI example')
+  c.setRecommended()
+  c.command('nothing', function (this: CommandBuilder) {
+    this.features
+  })
+  c.option('--opt1', 'opt1')
+  c.option('--opt2', 'opt2')
+  c.action((opts, cmd) => {
+    cmd.db.appData.update('count1', (c: number) => c + 1)
+    console.log(cmd.db.appData.get())
+  })
+
+  c.appData('count1', { defaultValue: 0 })
+  c.appData('count2', { defaultValue: 0 })
+  console.log(c.dataFilepath)
+})
+console.timeEnd('load')
+
+console.time('init')
+console.timeEnd('init')
+
+console.time('exec')
+cli.$.parse()
+console.timeEnd('exec')

package/src/_example/bFindIn.ts

@@ -0,0 +1,200 @@
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { execInherit } from '../util/node/execInherit'
+import { strSplitCamelCase } from '../util/string/strSplitCamelCase'
+
+console.time('load')
+
+const cli = new CommandBuilder('bFindIn', (b) => {
+  b.setRecommended()
+  b.version('0.0.1')
+  b.description(
+    [
+      "Search for 'PATTERN' inside files in 'DIRPATH'.",
+      '  Can search inside zip and binary files - and more.',
+      '',
+      "This is a wrapper for 'ag' which needs to be installed.",
+      '  https://github.com/JFLarvoire/the_silver_searcher',
+      '',
+      'Example Usage:',
+      `  ${b.name} matches keyword ./src`,
+      `  ${b.name} paths keyword --depth=1`,
+      `  ${b.name} file keyword readme.md --ignore-case`,
+    ].join('\n')
+  )
+
+  b.argument('<pattern>', 'search pattern')
+  b.argument('[dirpath]', 'dirpath to search')
+  // pattern settings
+  b.option('-i, --ignore-case', 'Case-insensitive')
+  b.option('-s, --case-sensitive', 'Case-sensitive.')
+  b.option('-Q, --literal', 'Do not parse PATTERN as a regular expression')
+  b.option('-m, --max-count <NUM>', (o) => {
+    o.description('Skip the rest of a file after NUM matches.')
+    o.parser.integer()
+    o.default(10000)
+  })
+  b.option('-w, --word-regexp', 'Only match whole words')
+  b.option('--invert-match', 'Match anything except PATTERN')
+  // navigation patterns
+  b.option('--ignore <names>', (o) => {
+    o.description('Comma-delimited list of dirnames to ignore')
+    o.parser.delimitedStrings(',')
+  })
+  b.option('-U, --skip-vcs-ignores', 'Ignore VCS ignore files (.gitignore, .hgignore; still obey .ignore)')
+  // directory selection
+  b.option('--depth <n>', (o) => {
+    o.description('Max directory depth.')
+    o.parser.integer()
+    o.default(25)
+  })
+  b.option('-f, --follow', 'Follow symlinks')
+  b.option('--one-device', 'Do not follow links to other devices.')
+  b.option('--path-to-ignore <PATH>', 'Filepath to file with paths to ignore.')
+  // file selection
+  b.option(
+    '-u, --unrestricted',
+    'Search all files (ignore .ignore, .gitignore, etc.; searches binary and hidden files as well).'
+  )
+  b.option(
+    '-z, --search-zip',
+    'Search contents of compressed (e.g., gzip) files. Note that Windows zip files are not supported.'
+  )
+  b.option('-a, --all-types', 'Search all files (does not include hidden files or patterns from ignore files)')
+  b.option('-t, --all-text', 'Search all text files (does not include hidden files)')
+  b.option('--ext <file-extensions>', (o) => {
+    o.description('Comma-delimited list of file extensions to include.')
+    o.parser.custom((string: string) => {
+      const arr = string
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+      if (arr.length === 1) return '"\\.' + arr[0] + '$"'
+      return '"\\.(' + arr.join('|') + ')$"'
+    })
+  })
+  // output modes
+  b.option('--files-with-matches', 'Only print filenames that contain matches (do not print the matching lines)')
+  b.option('--silent', 'Suppress all log messages, including errors')
+  b.option('--stats', 'Print stats (files scanned, time taken, etc.)')
+  b.option('--stats-only', 'Print stats and nothing else.')
+  // context
+  b.option('-B, --before <lines>', (o) => {
+    o.description('Print lines before match')
+    o.default(0)
+    o.parser.integer()
+  })
+  b.option('-A, --after <lines>', (o) => {
+    o.description('Print lines after match')
+    o.default(0)
+    o.parser.integer()
+  })
+  b.option('--nobreak', 'Disable printing newlines between matches in different files')
+  b.option('-W, --width <n>', (o) => {
+    o.description('Truncate match lines after n characters.')
+    o.parser.integer()
+  })
+  b.option('--column', 'Print column numbers in results')
+  b.option('--nonumbers', 'Print line numbers. Default is to omit line numbers when searching streams')
+  b.option('--filename', 'Print file names (Enabled unless searching a single file)')
+  b.option('--print-all-files', 'Print headings for all files searched, even those that do not contain matches')
+  b.option('-o, --only-matching', 'Prints only the matching part of the lines')
+  b.option('--print-long-lines', 'Print matches on very long lines (Default: >2k characters)')
+  b.option('-C, --context <lines>', (o) => {
+    o.description('Print lines before and after matches')
+    o.default(0)
+    o.parser.integer()
+  })
+  b.option('-H, --noheading', "Disable printing file names before each file's matches")
+  b.option('-c, --count', 'Only print file match counts. (Not always equal to matching lines count)')
+  // misc
+  b.option('-g, --filename-pattern <pattern>', 'Print filenames matching PATTERN')
+  b.option('-L, --files-without-matches', 'Only print filenames that do not contain matches')
+  b.option('--passthrough', 'When searching a stream, print all lines even if they do not match')
+  b.option('-0, --print0', "Separate filenames with null (for 'xargs -0')")
+  b.option('--ackmate', 'Print results in AckMate-parseable format')
+  b.option('--vimgrep', 'Print results like :vimgrep /pattern/g would in vim (reports every line match)')
+  // teminal colors
+  b.option('--nocolor', 'Disable printing color codes in results')
+  b.option('--color-line-number <cc>', (o) => {
+    o.description('Color codes for line numbers')
+    o.default('1;33')
+  })
+  b.option('--color-match <cc>', (o) => {
+    o.description('Color codes for result match numbers')
+    o.default('30;43')
+  })
+  b.option('--color-path <cc>', (o) => {
+    o.description('Color codes for path names')
+    o.default('1;32')
+  })
+  b.option('--color-win-ansi', 'Always use ANSI colors in Windows (except pager/pipe remain ANSI)')
+
+  ////////////////
+
+  b.action(async (pattern, dirpath, opts) => {
+    const args: string[] = []
+    for (const [k, value] of Object.entries(opts)) {
+      if (k === 'debug') continue
+      let key = strSplitCamelCase(k)
+        .map((s) => s.trim())
+        .join('-')
+        .toLowerCase()
+      if (key === 'ext') key = 'file-search-regex'
+
+      if (value == null || value === false) {
+        continue
+      }
+      if (b.options.find((o) => o.attributeName() === k)?.defaultValue === value) {
+        continue
+      }
+      if (value === true) {
+        args.push(`--${key}`)
+        continue
+      }
+      args.push(`--${key} "${value}"`)
+    }
+    const cmd = `ag ${args.join(' ')} ${pattern} ${dirpath || ''}`.trim()
+    console.log({ pattern, dirpath, opts, cmd })
+    await execInherit(cmd)
+  })
+
+  b.preset('#matches', {
+    description: 'Print matches found in each file',
+    options: { count: false, numbers: true, column: true, printLongLines: false, onlyMatching: true, width: 100 },
+  })
+  b.preset('#paths', {
+    description: 'Print only paths to files with matches',
+    options: { paths: true, maxCount: 1, silent: true },
+  })
+  b.preset('#bin', {
+    description: 'Search everything, including zipped, binary, and hidden files.',
+    options: {
+      unrestricted: true,
+      searchBinary: true,
+      searchZip: true,
+      hidden: true,
+      printLongLines: true,
+    },
+  })
+  b.preset('#text', {
+    description: 'Search all text files.',
+    options: {
+      allText: true,
+    },
+  })
+  b.preset('#ts', {
+    description: 'Search source code in a js/ts repository.',
+    args: [null, 'C:/Users/bemoj/repos'],
+    options: {
+      ext: '\\.(ts|tsx|json|js|jsx|md|css|html|txt)$',
+      ignore: 'node_modules',
+    },
+  })
+
+  ////////////////
+})
+console.timeEnd('load')
+
+console.time('exec')
+cli.$.parse()
+console.timeEnd('exec')