@bemoje/cli 0.0.6 → 0.0.8

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

@@ -1,40 +0,0 @@
-import { objUpdatePropertyDescriptors } from './objUpdatePropertyDescriptors'
-
-describe(objUpdatePropertyDescriptors.name, () => {
-  it('should update property descriptors of specified properties on the object', () => {
-    const object = {
-      name: 'John',
-      age: 30,
-    }
-    objUpdatePropertyDescriptors(object, ['name'], (descriptor, property) => ({
-      ...descriptor,
-      enumerable: false,
-    }))
-    expect(Object.getOwnPropertyDescriptor(object, 'name')).toEqual({
-      value: 'John',
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    })
-  })
-
-  it('should throw an error if a specified property does not exist on the object', () => {
-    const object = {
-      name: 'John',
-      age: 30,
-    }
-    expect(() => {
-      objUpdatePropertyDescriptors(object, ['address'], (descriptor, property) => descriptor)
-    }).toThrowError("Property, 'address' does not exist on object.")
-  })
-
-  it('should throw an error if any of the specified properties do not exist on the object', () => {
-    const object = {
-      name: 'John',
-      age: 30,
-    }
-    expect(() => {
-      objUpdatePropertyDescriptors(object, ['name', 'address'], (descriptor, property) => descriptor)
-    }).toThrowError("Property, 'address' does not exist on object.")
-  })
-})

package/src/util/object/objUpdatePropertyDescriptors.ts

@@ -1,29 +0,0 @@
-import type { ObjectKey } from '../types/ObjectKey'
-
-/**
- * Updates the property descriptors of the specified properties on the given object.
- * @param object - The object whose property descriptors are to be updated.
- * @param properties - An array of property names for which the descriptors are to be updated.
- * @param update - A function that takes a property descriptor and a property name, and returns a new property descriptor.
- * @throws Will throw an error if any of the specified properties do not exist on the object.
- * @example ```ts
- * const obj = { a: 1, b: 2 };
- * objUpdatePropertyDescriptors(obj, ['a', 'b'], (descriptor, property) => {
- *   descriptor.writable = true;
- *   return obj;
- * });
- * ```
- */
-export function objUpdatePropertyDescriptors<V>(
-  object: Record<ObjectKey, V>,
-  properties: string[],
-  update: <T extends PropertyDescriptor>(descriptor: T, property: string) => T
-): void {
-  for (const p of properties) {
-    if (!Reflect.has(object, p)) {
-      throw new Error(`Property, '${p}' does not exist on object.`)
-    }
-    const descriptor = update(Object.getOwnPropertyDescriptor(object, p) as PropertyDescriptor, p)
-    Object.defineProperty(object, p, descriptor)
-  }
-}

package/src/util/object/realizeLazyProperty.ts

@@ -1,9 +0,0 @@
-export function realizeLazyProperty<T>(obj: unknown, key: string, value: T) {
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    writable: false,
-    configurable: false,
-    value,
-  })
-  return value
-}

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

@@ -1,63 +0,0 @@
-import { setNonEnumerable } from './setNonEnumerable'
-
-describe(setNonEnumerable.name, () => {
-  it('should set the enumerable property to true.', () => {
-    const o = { a: 1 }
-    expect(Object.keys(o).includes('a')).toBe(true)
-    setNonEnumerable(o, 'a')
-    expect(Object.keys(o).includes('a')).toBe(false)
-  })
-
-  describe('when a property does not exist on the object', () => {
-    const object = {
-      prop1: 'value1',
-    }
-
-    it('should throw an error when one property does not exist', () => {
-      expect(() => setNonEnumerable(object, 'prop2')).toThrow("Property, 'prop2' does not exist on object.")
-    })
-
-    it('should throw an error when multiple properties do not exist', () => {
-      expect(() => setNonEnumerable(object, 'prop2', 'prop3')).toThrow("Property, 'prop2' does not exist on object.")
-    })
-  })
-
-  describe('when a property does not have a descriptor', () => {
-    Object.defineProperty(Object.prototype, 'inheritedProp', {
-      value: 'value2',
-      writable: true,
-      configurable: true,
-      enumerable: true,
-    })
-    const object = {
-      prop1: 'value1',
-    }
-
-    it('should throw an error when a property does not have a descriptor', () => {
-      expect(() => setNonEnumerable(object, 'inheritedProp')).toThrow()
-    })
-
-    it('should throw an error when multiple properties do not have a descriptor', () => {
-      expect(() => setNonEnumerable(object, 'inheritedProp', 'prop2')).toThrow()
-    })
-  })
-
-  describe('when all properties exist and have descriptors', () => {
-    const object = {
-      prop1: 'value1',
-      prop2: 'value2',
-    }
-
-    it('should make a single property non-enumerable', () => {
-      setNonEnumerable(object, 'prop1')
-      expect(Object.getOwnPropertyDescriptor(object, 'prop1')?.enumerable).toBe(false)
-      expect(Object.getOwnPropertyDescriptor(object, 'prop2')?.enumerable).toBe(true)
-    })
-
-    it('should make multiple properties non-enumerable', () => {
-      setNonEnumerable(object, 'prop1', 'prop2')
-      expect(Object.getOwnPropertyDescriptor(object, 'prop1')?.enumerable).toBe(false)
-      expect(Object.getOwnPropertyDescriptor(object, 'prop2')?.enumerable).toBe(false)
-    })
-  })
-})

package/src/util/object/setNonEnumerable.ts

@@ -1,22 +0,0 @@
-import type { ObjectKey } from '../types/ObjectKey'
-import { objUpdatePropertyDescriptors } from './objUpdatePropertyDescriptors'
-
-/**
- * Sets the specified properties of an object as non-enumerable.
- * @remarks This function modifies the original object by setting the specified properties as non-enumerable.
- * If the object or any of the property names are not valid, it throws an error.
- * @param object The object whose properties are to be set as non-enumerable.
- * @param properties The names of the properties to be set as non-enumerable.
- * @throws Will throw an error if any of the specified properties do not exist on the object.
- * @example ```ts
- * setNonEnumerable({ a: 1, b: 2, c: 3 }, 'a', 'b');
- * Object.keys({ a: 1, b: 2, c: 3 });;
- * //=> ['c']
- * ```
- */
-export function setNonEnumerable(object: Record<ObjectKey, any>, ...properties: string[]): void {
-  objUpdatePropertyDescriptors(object, properties, (descriptor) => {
-    descriptor.enumerable = false
-    return descriptor
-  })
-}

package/src/util/os/defaultOpenInEditorCommand.ts

@@ -1,14 +0,0 @@
-import { isOSX } from './isOSX'
-import { isVsCodeInstalled } from './isVsCodeInstalled'
-import { isWindows } from './isWindows'
-
-/**
- * Get the default command to open a file in in a text editor.
- * If VSCode is installed, this is used. Otherwise, the default text editor of the OS is used.
- */
-export function defaultOpenInEditorCommand() {
-  if (!COMMAND) COMMAND = isVsCodeInstalled() ? 'code -w' : isWindows() ? 'notepad' : isOSX() ? 'open vi' : 'xdg-open'
-  return COMMAND
-}
-
-let COMMAND = ''

package/src/util/os/isOSX.ts

@@ -1,9 +0,0 @@
-/**
- * Checks if the current platform is OSX.
- * It checks the 'process' object and the 'platform' property to determine if the platform is 'darwin'.
- * @returns A boolean indicating whether the current platform is OSX.
- */
-
-export function isOSX(): boolean {
-  return process.platform === 'darwin'
-}

package/src/util/os/isVsCodeInstalled.test.ts

@@ -1,7 +0,0 @@
-import { isVsCodeInstalled } from './isVsCodeInstalled'
-
-describe(isVsCodeInstalled.name, () => {
-  it('should return a boolean for whether VSCode is installed.', () => {
-    expect(typeof isVsCodeInstalled()).toBe('boolean')
-  })
-})

package/src/util/os/isVsCodeInstalled.ts

@@ -1,14 +0,0 @@
-import { execSync } from 'child_process'
-
-/**
- * Returns whether Visual Studio Code is installed on the system.
- * @example isVsCodeInstalled() //=> true
- */
-export function isVsCodeInstalled(): boolean {
-  try {
-    const stdout = execSync('code --help').toString()
-    return stdout.startsWith('Visual Studio Code') && stdout.includes('-w --wait')
-  } catch (e) {
-    return false
-  }
-}

package/src/util/os/isWindows.ts

@@ -1,12 +0,0 @@
-/**
- * Checks if the current platform is Windows.
- * @remarks
- * It checks the 'process' object and the 'platform' property to determine if the platform is 'win32'.
- * It also checks the 'OSTYPE' environment variable to see if it matches 'msys' or 'cygwin'.
- * @returns A boolean indicating whether the current platform is Windows.
- */
-export function isWindows(): boolean {
-  return isWin
-}
-
-const isWin = process && (process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env['OSTYPE'] || ''))

package/src/util/path/getTempDataPath.test.ts

@@ -1,9 +0,0 @@
-import { getTempDataPath } from './getTempDataPath'
-
-describe(getTempDataPath.name, () => {
-  it('returns the path to the os temp dir', () => {
-    expect(typeof getTempDataPath()).toBe('string')
-    expect(getTempDataPath('myapp').endsWith('myapp')).toBe(true)
-    expect(getTempDataPath('myapp', 'dir').endsWith('dir')).toBe(true)
-  })
-})

package/src/util/path/getTempDataPath.ts

@@ -1,14 +0,0 @@
-import fs from 'fs-extra'
-import os from 'os'
-import path from 'path'
-
-/**
- * Returns a path to the os tmpdir location.
- *
- * @param paths - The paths to join to the os tmpdir location.
- */
-export function getTempDataPath(...paths: string[]): string {
-  return path.join(tempdir, ...paths)
-}
-
-const tempdir = fs.realpathSync(os.tmpdir())

package/src/util/regex/regexEscapeString.test.ts

@@ -1,35 +0,0 @@
-import { regexEscapeString } from './regexEscapeString'
-
-describe('regexEscapeString', () => {
-  it('escapes correctly', () => {
-    expect(regexEscapeString('[click](google.com)')).toBe('\\[click\\]\\(google\\.com\\)')
-  })
-
-  it('works when creating RegExp object', () => {
-    expect(() => {
-      new RegExp(regexEscapeString('[.^$()]*(wow)+'), 'g')
-    }).not.toThrowError()
-  })
-
-  it('should escape special characters', () => {
-    const str = '.*+?^${}()|[\\]'
-    const expected = '\\.\\*\\+\\?\\^\\$\\{\\}\\(\\)\\|\\[\\\\\\]'
-    expect(regexEscapeString(str)).toBe(expected)
-  })
-
-  it('should return the same string if there are no special characters', () => {
-    const str = 'abc123'
-    expect(regexEscapeString(str)).toBe(str)
-  })
-
-  it('should handle empty strings', () => {
-    const str = ''
-    expect(regexEscapeString(str)).toBe(str)
-  })
-
-  it('should escape special characters in a string with alphanumeric characters', () => {
-    const str = 'abc.*+?^${}()|[\\]123'
-    const expected = 'abc\\.\\*\\+\\?\\^\\$\\{\\}\\(\\)\\|\\[\\\\\\]123'
-    expect(regexEscapeString(str)).toBe(expected)
-  })
-})

package/src/util/regex/regexEscapeString.ts

@@ -1,13 +0,0 @@
-/**
- * Escapes special characters in a string to be used in a regular expression.
- * @param str The input string to escape.
- * @returns The escaped string.
- * @example ```ts
- * const input = 'Hello, world!';
- * regexEscapeString(input);;
- * //=> 'Hello, world!'
- * ```
- */
-export function regexEscapeString(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // $& means the whole matched string
-}

package/src/util/string/strEnsureStartsWith.test.ts

@@ -1,13 +0,0 @@
-import { strEnsureStartsWith } from './strEnsureStartsWith'
-
-describe('strEnsureStartsWith', () => {
-  it('should return the original string if it already starts with the specified substring', () => {
-    const result = strEnsureStartsWith('.json', '.')
-    expect(result).toBe('.json')
-  })
-
-  it('should prepend the specified substring to the start of the string if it does not already start with it', () => {
-    const result = strEnsureStartsWith('json', '.')
-    expect(result).toBe('.json')
-  })
-})

package/src/util/string/strEnsureStartsWith.ts

@@ -1,14 +0,0 @@
-/**
- * Ensures that a string starts with a specified substring. If the string already starts with the specified substring, it is returned as is. Otherwise, the substring is appended to the end of the string.
- * @param string The string to be processed.
- * @param startsWith The substring that the string should end with.
- * @example ```ts
- * strEnsureStartsWith('json', '.');
- * //=> '.json'
- * strEnsureStartsWith('.json', '.');
- * //=> '.json'
- * ```
- */
-export function strEnsureStartsWith(string: string, startsWith: string): string {
-  return string.startsWith(startsWith) ? string : startsWith + string
-}

package/src/util/string/strFirstCharToUpperCase.test.ts

@@ -1,33 +0,0 @@
-import { strFirstCharToUpperCase } from './strFirstCharToUpperCase'
-
-describe('strFirstCharToUpperCase', () => {
-  it('should convert the first character of a string to uppercase', () => {
-    const result = strFirstCharToUpperCase('hello')
-    expect(result).toBe('Hello')
-  })
-
-  it('should return the same string if the first character is already uppercase', () => {
-    const result = strFirstCharToUpperCase('Hello')
-    expect(result).toBe('Hello')
-  })
-
-  it('should return the same string if it starts with a non-alphabetical character', () => {
-    const result = strFirstCharToUpperCase('1hello')
-    expect(result).toBe('1hello')
-  })
-
-  it('should return an empty string if the input is an empty string', () => {
-    const result = strFirstCharToUpperCase('')
-    expect(result).toBe('')
-  })
-
-  it('should handle strings with only one character', () => {
-    const result = strFirstCharToUpperCase('h')
-    expect(result).toBe('H')
-  })
-
-  it('should handle strings with only one uppercase character', () => {
-    const result = strFirstCharToUpperCase('H')
-    expect(result).toBe('H')
-  })
-})

package/src/util/string/strFirstCharToUpperCase.ts

@@ -1,11 +0,0 @@
-/**
- * Converts the first character of a string to uppercase.
- * @param string The string to be converted.
- * @example ```ts
- * strFirstCharToUpperCase('hello');
- * //=> 'Hello'
- * ```
- */
-export function strFirstCharToUpperCase(string: string): string {
-  return string.charAt(0).toUpperCase() + string.substring(1)
-}

package/src/util/string/strIsLowerCase.test.ts

@@ -1,42 +0,0 @@
-import { strIsLowerCase } from './strIsLowerCase'
-
-describe('strIsLowerCase', () => {
-  it('example', () => {
-    expect(strIsLowerCase('input')).toBe(true)
-    expect(strIsLowerCase('Input')).toBe(false)
-    expect(strIsLowerCase('')).toBe(true)
-    expect(strIsLowerCase('.')).toBe(true)
-  })
-
-  it('should return true for a lowercase string', () => {
-    expect(strIsLowerCase('hello')).toBe(true)
-  })
-
-  it('should return false for an uppercase string', () => {
-    expect(strIsLowerCase('HELLO')).toBe(false)
-  })
-
-  it('should return false for a mixed case string', () => {
-    expect(strIsLowerCase('Hello')).toBe(false)
-  })
-
-  it('should return true for an empty string', () => {
-    expect(strIsLowerCase('')).toBe(true)
-  })
-
-  it('should return true for a string with spaces', () => {
-    expect(strIsLowerCase('hello world')).toBe(true)
-  })
-
-  it('should return false for a string with spaces and uppercase letters', () => {
-    expect(strIsLowerCase('Hello World')).toBe(false)
-  })
-
-  it('should return true for a string with special characters', () => {
-    expect(strIsLowerCase('hello@world.com')).toBe(true)
-  })
-
-  it('should return false for a string with special characters and uppercase letters', () => {
-    expect(strIsLowerCase('Hello@World.com')).toBe(false)
-  })
-})

package/src/util/string/strIsLowerCase.ts

@@ -1,13 +0,0 @@
-/**
- * Checks if the given string is in lower case.
- * @param input The string to be checked.
- * @example ```ts
- * strIsLowerCase('hello');
- * //=> true
- * strIsLowerCase('Hello');
- * //=> false
- * ```
- */
-export function strIsLowerCase(input: string): boolean {
-  return input === input.toLowerCase()
-}

package/src/util/string/strIsUpperCase.test.ts

@@ -1,48 +0,0 @@
-import { strIsUpperCase } from './strIsUpperCase'
-
-describe('strIsUpperCase', () => {
-  it('example', () => {
-    expect(strIsUpperCase('INPUT')).toBe(true)
-    expect(strIsUpperCase('Input')).toBe(false)
-  })
-
-  it('should return true for a string in upper case', () => {
-    expect(strIsUpperCase('HELLO')).toBe(true)
-  })
-
-  it('should return false for a string in lower case', () => {
-    expect(strIsUpperCase('hello')).toBe(false)
-  })
-
-  it('should return false for a string in mixed case', () => {
-    expect(strIsUpperCase('Hello')).toBe(false)
-  })
-
-  it('should return true for a string with upper case special characters', () => {
-    expect(strIsUpperCase('HELLO WORLD!')).toBe(true)
-  })
-
-  it('should return false for a string with lower case special characters', () => {
-    expect(strIsUpperCase('hello world!')).toBe(false)
-  })
-
-  it('should return true for an empty string', () => {
-    expect(strIsUpperCase('')).toBe(true)
-  })
-
-  it('should return true for a string with only spaces', () => {
-    expect(strIsUpperCase('   ')).toBe(true)
-  })
-
-  it('should return true for a string with numbers', () => {
-    expect(strIsUpperCase('123')).toBe(true)
-  })
-
-  it('should return true for a string with upper case numbers and special characters', () => {
-    expect(strIsUpperCase('HELLO123!')).toBe(true)
-  })
-
-  it('should return false for a string with lower case numbers and special characters', () => {
-    expect(strIsUpperCase('hello123!')).toBe(false)
-  })
-})

package/src/util/string/strIsUpperCase.ts

@@ -1,13 +0,0 @@
-/**
- * Checks if the given string is in upper case.
- * @param input The string to be checked.
- * @example ```ts
- * strIsUpperCase('HELLO');;
- * //=> true
- * strIsUpperCase('HEllo');;
- * //=> false
- * ```
- */
-export function strIsUpperCase(input: string): boolean {
-  return input === input.toUpperCase()
-}

package/src/util/string/strSplitCamelCase.test.ts

@@ -1,54 +0,0 @@
-import { strSplitCamelCase } from './strSplitCamelCase'
-
-describe('strSplitCamelCase', () => {
-  it('example', () => {
-    expect(strSplitCamelCase('someCamelCase')).toStrictEqual(['some', 'Camel', 'Case'])
-  })
-
-  it('handles numbers', () => {
-    expect(strSplitCamelCase('camelCase18')).toStrictEqual(['camel', 'Case18'])
-    expect(strSplitCamelCase('camel18Case')).toStrictEqual(['camel18', 'Case'])
-    expect(strSplitCamelCase('camel18case')).toStrictEqual(['camel18case'])
-  })
-
-  it('should handle empty strings', () => {
-    expect(strSplitCamelCase('')).toEqual([])
-  })
-
-  it('should handle strings with only one character', () => {
-    expect(strSplitCamelCase('a')).toEqual(['a'])
-    expect(strSplitCamelCase('A')).toEqual(['A'])
-  })
-
-  it('should not split words with only two characters', () => {
-    expect(strSplitCamelCase('ab')).toEqual(['ab'])
-    expect(strSplitCamelCase('aB')).toEqual(['aB'])
-    expect(strSplitCamelCase('bA')).toEqual(['bA'])
-  })
-
-  it('handles short strings', () => {
-    expect(strSplitCamelCase('aWo')).toStrictEqual(['a', 'Wo'])
-    expect(strSplitCamelCase('aaWo')).toStrictEqual(['aa', 'Wo'])
-    expect(strSplitCamelCase('aaaW')).toStrictEqual(['aaa', 'W'])
-  })
-
-  it('should split camel case words correctly', () => {
-    expect(strSplitCamelCase('camelCaseWord')).toEqual(['camel', 'Case', 'Word'])
-    expect(strSplitCamelCase('anotherCamelCaseWord')).toEqual(['another', 'Camel', 'Case', 'Word'])
-  })
-
-  it('should return the word as it was if no splits needed', () => {
-    expect(strSplitCamelCase('word')).toEqual(['word'])
-    expect(strSplitCamelCase('anotherword')).toEqual(['anotherword'])
-  })
-
-  it('should handle strings with numeric characters', () => {
-    expect(strSplitCamelCase('camelCase1Word')).toEqual(['camel', 'Case1', 'Word'])
-    expect(strSplitCamelCase('anotherCamelCase2Word')).toEqual(['another', 'Camel', 'Case2', 'Word'])
-  })
-
-  it('should handle strings with special characters', () => {
-    expect(strSplitCamelCase('camelCase$Word')).toEqual(['camel', 'Case$', 'Word'])
-    expect(strSplitCamelCase('anotherCamelCase#Word')).toEqual(['another', 'Camel', 'Case#', 'Word'])
-  })
-})

package/src/util/string/strSplitCamelCase.ts

@@ -1,51 +0,0 @@
-import { strIsLowerCase } from './strIsLowerCase'
-import { strIsUpperCase } from './strIsUpperCase'
-
-/**
- * Returns an array of words in the string
- * @param word The camel case word to split.
- * @throws Throws an error if the input is not a string.
- * @param input input string
- * @example ```ts
- * strSplitCamelCase('someCamel10Case')
- * //=> ['some', 'Camel10', 'Case']
- * ```
- */
-export function strSplitCamelCase(word: string): string[] {
-  if (!word) return []
-  if (word.length <= 2) return [word]
-  const result: string[] = []
-  const lastCharIndex = word.length - 1
-  let lastSplitIndex = 0
-  let foundCamelCase = false
-  for (let i = 1; i < word.length; i++) {
-    if (isWordSplitIndex(word, i)) {
-      const sub = word.substring(lastSplitIndex, i)
-      if (sub) {
-        result.push(sub)
-        lastSplitIndex = i
-        foundCamelCase = true
-      }
-    }
-    if (foundCamelCase && i === lastCharIndex) {
-      const sub = word.substring(lastSplitIndex)
-      if (sub) result.push(sub)
-    }
-  }
-  if (!foundCamelCase) result.push(word)
-  return result
-}
-
-const regInteger = /\d+/g
-const regSpecial = /[^\w]+/g
-
-function isWordSplitIndex(word: string, index: number) {
-  return (
-    strIsLowerCase(word[index - 1]) &&
-    strIsUpperCase(word[index]) &&
-    !regInteger.test(word[index - 1]) &&
-    !regInteger.test(word[index]) &&
-    !regSpecial.test(word[index - 1]) &&
-    !regSpecial.test(word[index])
-  )
-}