@bemoje/cli 0.0.6 → 0.0.8

package/src/util/errors/ErrorParser.ts

@@ -1,165 +0,0 @@
-import colors from 'ansi-colors'
-import path from 'path'
-import type { Any } from '../types/Any'
-import { isPlainObject } from '../validation/isPlainObject'
-import { isPrimitive } from '../validation/isPrimitive'
-import { regexEscapeString } from '../regex/regexEscapeString'
-
-export class ErrorParser {
-  readonly error: Error
-
-  constructor(error: unknown) {
-    this.error = error instanceof Error ? error : new Error(String(error))
-  }
-
-  get name() {
-    return this.error.name
-  }
-
-  get message() {
-    return this.error.message
-  }
-
-  get stack(): string {
-    return this.error.stack || ''
-  }
-
-  summary() {
-    return this.name + ': ' + this.message
-  }
-
-  parseStackFrames() {
-    return errParseStack(this.stack)
-  }
-
-  prettyStack(parsedStackFrames?: [string, string][]) {
-    return errPrettyStack(this.error, parsedStackFrames)
-  }
-
-  toObject() {
-    return errToObject(this.error)
-  }
-
-  toJSON() {
-    return this.toObject()
-  }
-}
-
-export function errPrettyStack(error: Error, parsedStackFrames?: [string, string][]) {
-  const frames = parsedStackFrames ?? errParseStack(error.stack || '')
-
-  // width of the first column = the longest frame.cell string
-  const offset = 2 + frames.reduce((acc: number, frame) => Math.max(acc, frame[0].length), 0)
-
-  // type and message
-  const result = [
-    colors.bold(colors.red(error.name)) +
-      ': ' +
-      ' '.repeat(Math.max(0, offset - error.name.length)) +
-      colors.red(error.message),
-  ]
-
-  // stack trace
-  result.push(colors.yellow('stack') + ':')
-  result.push(
-    frames
-      .map((frame: [string, string]) => {
-        const [call, file] = frame
-        let s = '  '
-        let fp: string
-        if (file.startsWith('node:')) {
-          s += colors.gray(call)
-          fp = colors.gray(file)
-        } else if (file.includes('node_modules')) {
-          s += call
-          const base = path.basename(file.split(':')[0])
-          fp = file.replace(base, colors.yellow(base))
-        } else {
-          s += call
-          const base = path.basename(file.split(':')[0])
-          fp = file.replace(base, colors.red(base))
-        }
-        s += ' '.repeat(offset - call.length)
-        s += fp
-        return s
-      })
-      .join('\n')
-  )
-
-  // other properties
-  const ignore = ['name', 'message', 'frames', 'stack']
-  const keys = Object.getOwnPropertyNames(error).filter((key) => !ignore.includes(key))
-  for (const k of keys) {
-    if (typeof k === 'symbol') continue
-    const key = k as keyof typeof error
-    let s = colors.yellow(key.toString()) + ': '
-    if (isPlainObject(error[key])) {
-      const json = JSON.stringify(error[key], null, 2)
-      if (json.length < 350) {
-        s += JSON.stringify(error[key], null, 2)
-          .split('\n')
-          .map((line: string) => {
-            const arr = line.split('": ')
-            arr[0] = colors.gray(arr[0].replace('"', ''))
-            return arr.join(': ')
-          })
-          .join('\n')
-      } else {
-        s += JSON.stringify(error[key])
-      }
-    } else if (isPrimitive(error[key])) {
-      s += String(error[key])
-    } else if (error[key] != null && typeof error[key] === 'object') {
-      s += (error[key] as Any).toString()
-    } else {
-      s += JSON.stringify(error[key])
-    }
-    result.push(s.trim())
-  }
-  return '\n' + result.join('\n') + '\n'
-}
-
-export function errParseStack(stack: string): [string, string][] {
-  if (!stack) return []
-  const nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i
-  const recwd = new RegExp('^' + regexEscapeString(process.cwd() + path.sep), 'i')
-  const frames: [string, string][] = []
-  for (const line of stack.split('\n')) {
-    const parts = nodeRe.exec(line)
-    if (!parts) continue
-    frames.push([
-      parts[1] || '<unknown>',
-      `${(parts[2] || '').replace(recwd, '').replace(/\\\\?/g, '/')}:${+parts[3]}:${parts[4] ? +parts[4] : null}`,
-    ])
-  }
-  return frames
-}
-
-export function errToObject(error: Error) {
-  const own = Object.getOwnPropertyNames(error).filter((key) => typeof key === 'string')
-  const keys = new Set(['name', 'message', 'frames', ...own])
-  keys.delete('stack')
-  const entries = Array.from(keys)
-    .filter((key) => error[key as keyof Error] !== undefined)
-    .map((key) => [key, error[key as keyof Error]])
-  return Object.fromEntries(entries)
-}
-
-// try {
-//   throw new TypeError('wow ok oops')
-// } catch (error) {
-//   const err = new ErrorParser(error)
-//   console.log('----------------------')
-//   console.log({
-//     name: err.name,
-//     message: err.message,
-//     summary: err.summary,
-//   })
-//   console.log('----------------------')
-//   console.log(err.stack)
-//   console.log('----------------------')
-//   console.log(err.prettyStack())
-//   console.log('----------------------')
-//   console.log(err.toObject())
-//   console.log('----------------------')
-// }

package/src/util/fs/promptUserEditInTextEditor/IGetUserInputFromEditorOptions.ts

@@ -1,15 +0,0 @@
-export interface IGetUserInputFromEditorOptions {
-  /**
-   * The content to put in the temp file so that the user can edit it. Defaults to an empty file.
-   */
-  content?: string
-  /**
-   * Launch command to start your editor. Defaults to VSCode: 'code -w' (if installed).
-   * Otherwise this logic: isWindows() ? 'notepad' : isOSX() ? 'open vi' : 'xdg-open'
-   */
-  editor?: string
-  /**
-   * The file extension to use for the temporary file. Defaults to '.txt'.
-   */
-  extension?: string
-}

package/src/util/fs/promptUserEditInTextEditor/promptUserEditInTextEditorSync.ts

@@ -1,30 +0,0 @@
-import { defaultOpenInEditorCommand } from '../../os/defaultOpenInEditorCommand'
-import { execSync } from 'child_process'
-import type { IGetUserInputFromEditorOptions } from './IGetUserInputFromEditorOptions'
-import { readFileSync } from '../readFile/readFileSync'
-import { strEnsureStartsWith } from '../../string/strEnsureStartsWith'
-import { tempFileSync } from '../tempFile/tempFileSync'
-import { writeFileSync } from '../writeFile/writeFileSync'
-
-/**
- * Prompts the user to edit a string in the user's text editor.
- *
- * @example ```ts
- * promptUserEditInTextEditor({ editor: 'notepad' })
- * ```
- */
-export function promptUserEditInTextEditorSync(options?: IGetUserInputFromEditorOptions): string {
-  const { editor, content, extension } = applyDefaults(options)
-  return tempFileSync(extension, (tempfile) => {
-    writeFileSync(tempfile, content)
-    execSync(`${editor} ${tempfile}`, { stdio: 'inherit' })
-    return readFileSync(tempfile)
-  })
-}
-
-function applyDefaults(options: IGetUserInputFromEditorOptions = {}) {
-  const content = options.content ?? ''
-  const extension = strEnsureStartsWith(options.extension ?? '.txt', '.')
-  const editor = options.editor ?? defaultOpenInEditorCommand()
-  return { content, extension, editor }
-}

package/src/util/fs/promptUserEditInTextEditor/promptUserEditJsonInTextEditorSync.ts

@@ -1,25 +0,0 @@
-import type { JsonValue } from '../../types/JsonValue'
-import { promptUserEditInTextEditorSync } from './promptUserEditInTextEditorSync'
-
-/**
- * Edit a JSON-stringify-compatible value in the user's editor and return the (JSON.parse'd) result.
- *
- * @param value - The value to edit (NOT a json string). Defaults to an empty object.
- * @param editor - Launch command to start your editor. Defaults to VSCode: 'code -w' (if installed).
- * - Otherwise this logic: isWindows() ? 'notepad' : isOSX() ? 'open vi' : 'xdg-open'
- *
- * @example ```ts
- * promptUserEditJsonInTextEditorSync([1, 2])
- * ```
- */
-export function promptUserEditJsonInTextEditorSync<T extends JsonValue = JsonValue, R extends T = T>(
-  value: T = {} as T,
-  editor?: string
-): R {
-  const json = promptUserEditInTextEditorSync({
-    editor,
-    content: JSON.stringify(value, null, 2),
-    extension: '.json',
-  })
-  return JSON.parse(json) as R
-}

package/src/util/fs/readFile/readFileSafeSync.ts

@@ -1,20 +0,0 @@
-import fs from 'fs-extra'
-
-/**
- * Reads a file and returns the file's contents.
- *
- * Identical to fs.readFileSync, except that:
- * - it uses utf8 encoding by default
- * - if operation fails, returns undefined instead of throwing
- *
- * @param filepath - The path to the file.
- * @param encoding - The encoding to use when reading the file.
- * @returns The file's contents or undefined if the file does not exist.
- */
-export function readFileSafeSync(filepath: string, encoding: BufferEncoding = 'utf8'): string | undefined {
-  try {
-    return fs.readFileSync(filepath, encoding)
-  } catch (error) {
-    return undefined
-  }
-}

package/src/util/fs/readFile/readFileSync.ts

@@ -1,13 +0,0 @@
-import fs from 'fs-extra'
-
-/**
- * Reads a file and returns the file's contents.
- * Identical to fs.readFileSync, except that it uses utf8 encoding by default.
- *
- * @param filepath - The path to the file.
- * @param encoding - The encoding to use when reading the file.
- * @returns The file's contents.
- */
-export function readFileSync(filepath: string, encoding: BufferEncoding = 'utf8'): string {
-  return fs.readFileSync(filepath, encoding)
-}

package/src/util/fs/readJsonFile/readJsonFileSafeSync.ts

@@ -1,17 +0,0 @@
-import fs from 'fs-extra'
-import type { IReadJsonFileOptions } from '../types/IReadJsonFileOptions'
-
-/**
- * Reads a JSON file and then parses it into an object.
- * If an error occurs, it returns undefined.
- *
- * @param filepath - The path to the JSON file.
- * @param options - Options for reading the JSON file.
- */
-export function readJsonFileSafeSync<T>(filepath: string, options?: IReadJsonFileOptions): T | undefined {
-  try {
-    return fs.readJsonSync(filepath, options) as T
-  } catch (error) {
-    return undefined
-  }
-}

package/src/util/fs/removeFile/removeFile.ts

@@ -1 +0,0 @@
-export { remove as removeFile } from 'fs-extra'

package/src/util/fs/tempFile/tempFileSync.ts

@@ -1,21 +0,0 @@
-import fs from 'fs-extra'
-import type { Any } from '../../types/Any'
-import { getTempDataPath } from '../../path/getTempDataPath'
-import { strEnsureStartsWith } from '../../string/strEnsureStartsWith'
-
-/**
- * Syncrhonously creates a temporary file and deletes it after the callback has finished.
- * @param fileExtension - The file extension to use for the temporary file.
- * @param callback - The callback to execute with the temporary file path. The callback can return a promise and the temporary file will not be deleted until the promise has resolved or rejected.
- */
-export function tempFileSync(fileExtension: string, callback: (fpath: string) => Any) {
-  const fpath = getTempDataPath('temp', Date.now() + strEnsureStartsWith(fileExtension, '.'))
-  fs.ensureFileSync(fpath)
-  try {
-    const retval = callback(fpath)
-    fs.remove(fpath)
-    return retval
-  } catch (error) {
-    fs.remove(fpath)
-  }
-}

package/src/util/fs/types/IReadJsonFileOptions.ts

@@ -1 +0,0 @@
-export type { JFReadOptions as IReadJsonFileOptions } from 'jsonfile'

package/src/util/fs/writeFile/writeFileSafeSync.ts

@@ -1 +0,0 @@
-export { outputFileSync as writeFileSafeSync } from 'fs-extra'

package/src/util/fs/writeFile/writeFileSync.ts

@@ -1 +0,0 @@
-export { writeFileSync } from 'fs-extra'

package/src/util/fs/writeJsonFile/writeJsonFileSafe.ts

@@ -1 +0,0 @@
-export { outputJson as writeJsonFileSafe } from 'fs-extra'

package/src/util/function/MethodDisabler.test.ts

@@ -1,112 +0,0 @@
-import assert from 'assert'
-import { Any } from '../types/Any'
-import { MethodDisabler } from './MethodDisabler'
-import { ObjectKey } from '../types/ObjectKey'
-
-describe(MethodDisabler.name, () => {
-  it('TSDOC @example', () => {
-    expect(() => {
-      const md = new MethodDisabler(process.stdout, 'write')
-
-      md.disable()
-      assert(!md.isEnabled)
-      console.log('This will not print')
-
-      md.enable()
-      assert(md.isEnabled)
-      // console.log('This will print')
-
-      assert(md.original === process.stdout.write)
-    }).not.toThrow()
-  })
-
-  describe('constructor', () => {
-    it('instanceof ' + MethodDisabler.name, () => {
-      expect(new MethodDisabler(Array.prototype, 'sort')).toBeInstanceOf(MethodDisabler)
-    })
-
-    it('throws if not function', () => {
-      expect(() => new MethodDisabler(Array.prototype, 'length')).toThrow()
-    })
-
-    it('original', () => {
-      expect(new MethodDisabler(Array.prototype, 'sort').original).toBe(Array.prototype['sort'])
-    })
-
-    it('memoize', () => {
-      const ins = new MethodDisabler(Map.prototype, 'set')
-      expect(ins).toBe(new MethodDisabler(Map.prototype, 'set'))
-      expect(ins).not.toBe(new MethodDisabler(Map.prototype, 'get'))
-      expect(ins).not.toBe(new MethodDisabler(WeakMap.prototype, 'set'))
-    })
-  })
-
-  type Obj = Record<ObjectKey, Any>
-  type BfOpts = { obj: Obj; key: string }
-  type Opts = { ins: MethodDisabler; obj: Obj; key: string; spy?: jest.SpyInstance }
-
-  const createMock = (opts: BfOpts) => {
-    const { obj, key } = opts
-    jest.clearAllMocks()
-    const spy = jest.spyOn(obj, key)
-    spy.mockImplementation(() => false)
-    return spy
-  }
-
-  const createInstance = (opts: BfOpts) => {
-    const { obj, key } = opts
-    jest.clearAllMocks()
-    return new MethodDisabler(obj, key)
-  }
-
-  const testIsEnabled = (opts: Opts) => () => {
-    const { ins, obj, key, spy } = opts
-    expect(ins.isEnabled).toBe(true)
-    obj[key]('')
-    if (spy) expect(spy).toHaveBeenCalledTimes(1)
-  }
-
-  const testDisable = (opts: Opts) => () => {
-    const { ins, obj, key, spy } = opts
-    ins.disable()
-    expect(obj[key]).not.toBe(ins.original)
-    expect(ins.isEnabled).toBe(false)
-    obj[key]('')
-    if (spy) expect(spy).not.toHaveBeenCalled()
-  }
-
-  const testEnable = (opts: Opts) => () => {
-    const { ins, obj, key, spy } = opts
-    ins.disable()
-    ins.enable()
-    expect(obj[key]).toBe(ins.original)
-    if (spy) createMock({ obj, key })
-    testIsEnabled(opts)
-  }
-
-  const runTest = (opts: Opts) => {
-    const bopts = { obj: opts.obj, key: opts.key }
-    beforeEach(() => {
-      opts.ins = createInstance(bopts)
-      if (opts.spy) opts.spy = createMock(bopts)
-    })
-    it('isEnabled', testIsEnabled(opts))
-    it('disable', testDisable(opts))
-    it('enable', testEnable(opts))
-  }
-
-  describe('console.log (hasOwn)', () => {
-    const bopts = { obj: console, key: 'log' }
-    runTest({ ...bopts, ins: createInstance(bopts), spy: createMock(bopts) })
-  })
-
-  describe('process.stdout.write', () => {
-    const bopts = { obj: process.stdout, key: 'write' }
-    runTest({ ...bopts, ins: createInstance(bopts), spy: createMock(bopts) })
-  })
-
-  describe('[].push ', () => {
-    const bopts = { obj: [], key: 'join' }
-    runTest({ ...bopts, ins: createInstance(bopts) })
-  })
-})

package/src/util/function/MethodDisabler.ts

@@ -1,94 +0,0 @@
-import type { Any } from '../types/Any'
-import { ensureThat } from '../validation/ensureThat'
-import { isFunction } from '../validation/isFunction'
-import type { ObjectKey } from '../types/ObjectKey'
-import type { TFunctionNoNew } from '../types/TFunctionNoNew'
-
-/**
- * A class that creates an object with methods for disabling/enabling a given method on a given object.
- *
- * @example
- * const md = new MethodDisabler(process.stdout, 'write')
- *
- * md.disable()
- * assert(!md.isEnabled)
- * console.log('This will not print')
- *
- * md.enable()
- * assert(md.isEnabled)
- * console.log('This will print')
- *
- * assert(md.original === process.stdout.write)
- */
-export class MethodDisabler {
-  static #defaultDescriptor(value: Any): PropertyDescriptor {
-    return { value, writable: true, enumerable: true, configurable: true }
-  }
-  static #noop: TFunctionNoNew = (...args: any[]) => void 0
-  static #memoized = new WeakMap<Record<ObjectKey, Any>, Map<ObjectKey, MethodDisabler>>()
-
-  readonly #obj: Record<ObjectKey, Any>
-  readonly #key: string
-  readonly #original: TFunctionNoNew
-  readonly #hasOwn: boolean
-  readonly #originalDescriptor: PropertyDescriptor
-  readonly #noopDescriptor: PropertyDescriptor
-  #isEnabled = true
-
-  /**
-   * @param obj - The object on which the method is defined.
-   * @param key - The property name of the method.
-   */
-  constructor(obj: Record<ObjectKey, Any>, key: string) {
-    ensureThat(obj[key], isFunction)
-    this.#obj = obj
-    this.#key = key
-    this.#original = obj[key]
-    this.#hasOwn = Object.hasOwn(obj, key)
-    this.#originalDescriptor = this.#hasOwn
-      ? (Object.getOwnPropertyDescriptor(obj, key) as PropertyDescriptor)
-      : MethodDisabler.#defaultDescriptor(this.#original)
-    this.#noopDescriptor = Object.assign({}, this.#originalDescriptor, { value: MethodDisabler.#noop })
-    // return stored if memoized
-    if (MethodDisabler.#memoized.get(obj)?.has(key)) {
-      return MethodDisabler.#memoized.get(obj)?.get(key) as this
-    }
-    //memoize
-    if (!MethodDisabler.#memoized.has(obj)) MethodDisabler.#memoized.set(obj, new Map())
-    const methods = MethodDisabler.#memoized.get(obj) as Map<ObjectKey, MethodDisabler>
-    methods.set(key, this)
-  }
-
-  /**
-   * Disable the method.
-   */
-  disable() {
-    if (!this.isEnabled) return
-    Object.defineProperty(this.#obj, this.#key, this.#noopDescriptor)
-    this.#isEnabled = false
-  }
-
-  /**
-   * Enable the method.
-   */
-  enable() {
-    if (this.isEnabled) return
-    if (this.#hasOwn) Object.defineProperty(this.#obj, this.#key, this.#originalDescriptor)
-    else delete this.#obj[this.#key]
-    this.#isEnabled = true
-  }
-
-  /**
-   * The original method before it was disabled.
-   */
-  get original() {
-    return this.#original
-  }
-
-  /**
-   * Whether the method is currently enabled.
-   */
-  get isEnabled() {
-    return this.#isEnabled
-  }
-}

package/src/util/function/funSetName.test.ts

@@ -1,12 +0,0 @@
-import { funSetName } from './funSetName'
-
-describe('funSetName', () => {
-  it('should set the name of a function', () => {
-    expect(
-      funSetName('myFunc', function () {
-        //
-      }).name,
-    ).toBe('myFunc')
-    expect(funSetName('myFunc', () => 1).name).toBe('myFunc')
-  })
-})

package/src/util/function/funSetName.ts

@@ -1,16 +0,0 @@
-/**
- * This function sets the name of a function and returns the function with the new name.
- * @template T - The type of the function.
- * @param name The new name to be set for the function.
- * @param fun The function whose name is to be set.
- * @returns The function with the new name.
- * @example ```ts
- * const myFun = () => 'Hello World';
- * funSetName('newFun', myFun).name;;
- * //=> 'newFun'
- * ```
- */
-export function funSetName<T>(name: string, fun: T): T {
-  Object.defineProperty(fun, 'name', { value: name, configurable: true, writable: true, enumerable: false })
-  return fun
-}

package/src/util/node/execInherit.ts

@@ -1,14 +0,0 @@
-import { execSync } from 'child_process'
-
-export function execInherit(command: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    try {
-      const buffer = execSync(command, { stdio: 'inherit' })
-      const string = buffer && buffer.toString ? buffer.toString().trim() : ''
-      resolve(string)
-    } catch (error) {
-      const oError = error instanceof Error ? error : new Error(String(error))
-      reject(oError)
-    }
-  })
-}

package/src/util/node/formatTableForTerminal.ts

@@ -1,12 +0,0 @@
-import colors from 'ansi-colors'
-import Table from 'cli-table'
-
-export function formatTableForTerminal(rows: string[][], headers?: string[]) {
-  if (!rows.length || !rows[0].length) return ''
-  const table = new Table()
-  if (headers && headers.length) {
-    table.push(headers.map((s) => colors.bold(colors.yellow(s))))
-  }
-  for (const row of rows) table.push(row)
-  return table.toString()
-}

package/src/util/object/arrAssign.ts

@@ -1,3 +0,0 @@
-import { createArrayMerger } from './createArrayMerger'
-
-export const arrAssign = createArrayMerger((value) => value != null)

package/src/util/object/createArrayMerger.test.ts

@@ -1,11 +0,0 @@
-import { createArrayMerger } from './createArrayMerger'
-
-describe(createArrayMerger.name, () => {
-  it('should merge arrays based on the predicate function', () => {
-    const merge = createArrayMerger<number>((value) => value != null)
-    const target = [1, 3, 5, 7]
-    const source1 = [2, 4, 6]
-    const result = merge(target, source1)
-    expect(result).toEqual([2, 4, 6, 7])
-  })
-})

package/src/util/object/createArrayMerger.ts

@@ -1,15 +0,0 @@
-/**
- * Creates a function that merges arrays based on a predicate function.
- */
-export function createArrayMerger<T>(predicate: (value: T, index: number, arr: T[]) => boolean) {
-  return function arrMerge<E extends T>(target: E[], ...sources: E[][]) {
-    for (const src of sources) {
-      for (let i = 0; i < src.length; i++) {
-        if (predicate(src[i], i, src)) {
-          target[i] = src[i]
-        }
-      }
-    }
-    return target
-  }
-}

package/src/util/object/createObjectMerger.test.ts

@@ -1,11 +0,0 @@
-import { createObjectMerger } from './createObjectMerger'
-
-describe(createObjectMerger.name, () => {
-  it('should merge objects based on the predicate function', () => {
-    const merge = createObjectMerger((value) => value != null)
-    const target = { a: 1, b: 2, c: 3 }
-    const source1 = { a: 5, b: null, c: undefined, d: 5 }
-    const result = merge(target, source1)
-    expect(result).toEqual({ a: 5, b: 2, c: 3, d: 5 })
-  })
-})

package/src/util/object/createObjectMerger.ts

@@ -1,17 +0,0 @@
-import type { Any } from '../types/Any'
-
-/**
- * Creates a function that merges objects based on a predicate function.
- */
-export function createObjectMerger(predicate: (value: Any, key: string, obj: Record<string, Any>) => boolean) {
-  return function objMerge(target: Record<string, Any>, ...sources: Record<string, Any>[]) {
-    for (const src of sources) {
-      for (const [key, value] of Object.entries(src)) {
-        if (predicate(value, key, src)) {
-          target[key] = value
-        }
-      }
-    }
-    return target
-  }
-}

package/src/util/object/objAssign.ts

@@ -1,3 +0,0 @@
-import { createObjectMerger } from './createObjectMerger'
-
-export const objAssign = createObjectMerger((value) => value != null)