@bemoje/cli 0.0.4 → 0.0.6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,51 @@
+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])
+  )
+}