@bemoje/cli 0.0.5 → 0.0.8

package/scripts/_example/CommandBuilder.example2.ts

@@ -1,31 +0,0 @@
-import { CLI, CommandBuilder } from '../../src'
-
-console.time('load')
-
-const init = CLI('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')
-const cli = init()
-console.timeEnd('init')
-
-console.time('exec')
-cli.parse()
-console.timeEnd('exec')

package/scripts/_example/CommandBuilder.example3.ts

@@ -1,20 +0,0 @@
-import { CLI } from '../../src/cmd/CLI'
-
-console.time('load')
-
-const init = CLI('demo', (c) => {
-  c.argument('[arg1...]', (a) => a.default('lol'))
-  c.argument('[arg2]')
-  c.action((arg1, arg2, arg3) => {
-    console.log({ arg1, arg2, arg3 })
-  })
-})
-console.timeEnd('load')
-
-console.time('init')
-const cli = init()
-console.timeEnd('init')
-
-console.time('exec')
-cli.parse()
-console.timeEnd('exec')

package/scripts/_example/bFindIn.ts

@@ -1,207 +0,0 @@
-import { CLI } from '../../src/cmd/CLI'
-import { execInherit } from '../../src/util/node/execInherit'
-import { printCounts } from '../../src/core/counter'
-import { strSplitCamelCase } from '../../src/util/string/strSplitCamelCase'
-
-console.time('load')
-
-const init = CLI('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('init')
-const cli = init()
-console.timeEnd('init')
-
-console.time('exec')
-cli.parse()
-console.timeEnd('exec')
-
-printCounts()

package/scripts/currentBemojeUtils.txt

@@ -1,41 +0,0 @@
-'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

@@ -1,184 +0,0 @@
-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/arg/ArgumentBuilder.test.ts

@@ -1,102 +0,0 @@
-import { Argument } from '@commander-js/extra-typings'
-import { ArgumentBuilder } from './ArgumentBuilder'
-import { ArgumentParserSelector } from './ArgumentParserSelector'
-import { ArgumentReader } from './ArgumentReader'
-import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
-import { CommandBuilder } from '../cmd/CommandBuilder'
-
-describe(ArgumentBuilder.name, () => {
-  it('should add commander argument to commander command instance', () => {
-    new CommandBuilder('t', (c) => {
-      const spy = jest.spyOn(c.$, 'addArgument')
-      c.argument('[arg]', (a) => {
-        expect(spy).toBeCalledWith(a.$)
-      })
-    })
-  })
-
-  describe('constructor', () => {
-    it('$ should return an Argument instance', () => {
-      const o = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(o.$).toBeInstanceOf(Argument)
-    })
-
-    it('get should return an ArgumentReader instance', () => {
-      const o = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(o.get).toBeInstanceOf(ArgumentReader)
-    })
-
-    it('name', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          expect(a.$.name()).toBe('arg')
-        })
-      })
-    })
-  })
-
-  describe('description', () => {
-    it('set inside callback', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          expect(a.description('abc')).toBe(a)
-          expect(a.$.description).toBe('abc')
-        })
-        const arg = c.arguments[0]
-        expect(arg.description).toBe('abc')
-      })
-    })
-
-    it('set as second argument', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', 'abc')
-        const arg = c.arguments[0]
-        expect(arg.description).toBe('abc')
-      })
-    })
-
-    it('allow no description', () => {
-      new CommandBuilder('t', (c) => {
-        expect(() => c.argument('[arg]')).not.toThrow()
-      })
-    })
-  })
-
-  describe('default', () => {
-    it('should call commander default method', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          const spy = jest.spyOn(a.$, 'default')
-          expect(a.default('abc')).toBe(a)
-          expect(spy).toHaveBeenCalledTimes(1)
-        })
-      })
-    })
-  })
-
-  describe('choices', () => {
-    it('should call commander choices method', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          const spy = jest.spyOn(a.$, 'choices')
-          expect(a.choices(['a', 'b'])).toBe(a)
-          expect(spy).toHaveBeenCalledWith(['a', 'b'])
-        })
-      })
-    })
-  })
-
-  describe('parser', () => {
-    it('should return a ArgumentParserSelector instance', () => {
-      const arg = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(arg.parser).toBeInstanceOf(ArgumentParserSelector)
-    })
-  })
-
-  describe('validator', () => {
-    it('should return a ArgumentValidatorSelector instance', () => {
-      const arg = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(arg.validator).toBeInstanceOf(ArgumentValidatorSelector)
-    })
-  })
-})

package/src/arg/ArgumentBuilder.ts

@@ -1,47 +0,0 @@
-import { Argument } from '@commander-js/extra-typings'
-import { ArgumentParserSelector } from './ArgumentParserSelector'
-import { ArgumentReader } from './ArgumentReader'
-import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
-import { CommandBuilder } from '../cmd/CommandBuilder'
-import { realizeLazyProperty } from '../util/object/realizeLazyProperty'
-
-/**
- * Wrapper around the @see Argument class from 'commander'.
- */
-export class ArgumentBuilder {
-  readonly $: Argument
-  readonly index: number
-
-  constructor(readonly cmd: CommandBuilder, name: string) {
-    this.$ = new Argument(name)
-    this.index = cmd.meta.argValidators.length
-    cmd.meta.argValidators[this.index] = []
-  }
-
-  description(string: string) {
-    this.$.description = string
-    return this
-  }
-
-  default(value: unknown, description?: string) {
-    this.$.default(value, description)
-    return this
-  }
-
-  choices(values: readonly string[]) {
-    this.$.choices(values)
-    return this
-  }
-
-  get parser() {
-    return new ArgumentParserSelector(this)
-  }
-
-  get validator() {
-    return new ArgumentValidatorSelector(this)
-  }
-
-  get get() {
-    return realizeLazyProperty(this, 'get', new ArgumentReader(this))
-  }
-}

package/src/arg/ArgumentParserSelector.test.ts

@@ -1,53 +0,0 @@
-import { ArgumentParserSelector } from './ArgumentParserSelector'
-import { CLI } from '../cmd/CLI'
-
-describe(ArgumentParserSelector.name, () => {
-  it('should parse string, number, integer', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<str>', (a) => a.parser.string())
-      c.argument('<num>', (a) => a.parser.number())
-      c.argument('<int>', (a) => a.parser.integer())
-      c.action((str, num, int) => {
-        expect(str).toBe('str')
-        expect(num).toBe(3.2)
-        expect(int).toBe(3)
-      })
-    })
-    run().parse(['str', '3.2', '3'], { from: 'user' })
-  })
-
-  it('should parse variadic argument', () => {
-    const init = CLI('t', (c) => {
-      c.argument('<str>', (o) => o.parser.string())
-      c.argument('<ints...>', (o) => o.parser.integer())
-      c.action((str, ints) => {
-        expect(ints).toEqual([3, 4, 5])
-      })
-    })
-    init().parse('abc 3 4 5'.split(' '), { from: 'user' })
-  })
-
-  it('should parse delimited string, number, integer', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<strs>', (a) => a.parser.delimitedStrings())
-      c.argument('<nums>', (a) => a.parser.delimitedNumbers())
-      c.argument('<ints>', (a) => a.parser.delimitedIntegers())
-      c.action((strs, nums, ints) => {
-        expect(strs).toEqual(['a', 'b'])
-        expect(nums).toEqual([3.1, 4.1])
-        expect(ints).toEqual([3, 4, 5])
-      })
-    })
-    run().parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })
-  })
-
-  it('should parse with custom parser', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<arg>', (a) => a.parser.custom((s) => s.split('')))
-      c.action((arg) => {
-        expect(arg).toEqual(['a', 'b', 'c'])
-      })
-    })
-    run().parse(['abc'], { from: 'user' })
-  })
-})