@bemoje/cli 0.0.4 → 0.0.6

package/src/util/errors/ErrorParser.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * 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

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

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

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

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

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

@@ -0,0 +1,15 @@
+/**
+ * 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

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

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

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