@involvex/emoji-cli 2.2.2

package/src/emojify.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+
+import { emojify } from './emojify.js'
+
+describe('emojify', () => {
+  it('handles flags correctly', () => {
+    expect(
+      emojify('Mexico :mexico: and Morocco :morocco: are not the same'),
+    ).toBe('Mexico 🇲🇽 and Morocco 🇲🇦 are not the same')
+  })
+
+  it('leaves unknown emoji when no fallback is provided', () => {
+    expect(emojify('I :unknown_emoji: :star: :another_one:')).toBe(
+      'I :unknown_emoji: ⭐ :another_one:',
+    )
+  })
+
+  it('replaces unknown emoji with the fallback when a fallback string is provided', () => {
+    expect(
+      emojify('I :unknown_emoji: :star: :another_one:', {
+        fallback: 'unknown',
+      }),
+    ).toBe('I unknown ⭐ unknown')
+  })
+
+  it('replaces unknown emoji with the fallback when a fallback function is provided', () => {
+    expect(
+      emojify('I :unknown_emoji: :star: :another_one:', {
+        fallback: part => `(${part})`,
+      }),
+    ).toBe('I (unknown_emoji) ⭐ (another_one)')
+  })
+
+  it('parses a single :emoji: in a string when there is only one emoji', () => {
+    expect(emojify(':coffee:!')).toBe('☕!')
+  })
+
+  it('parses multiple :emoji: in a string when there are multiple emoji', () => {
+    expect(
+      emojify(
+        'I :heart:  :coffee:! -  :hushed::star::heart_eyes:  ::: test : : :+1:+',
+      ),
+    ).toBe('I ❤️  ☕! -  😯⭐😍  ::: test : : 👍+')
+  })
+
+  it('formats emoji when given a format function', () => {
+    expect(
+      emojify('I :unknown_emoji: :star: :another_one:', {
+        format: name => `[${name}]`,
+      }),
+    ).toBe('I [:unknown_emoji:] [⭐] [:another_one:]')
+  })
+})

package/src/emojify.ts

@@ -0,0 +1,50 @@
+import is from '@sindresorhus/is'
+
+import { findByName } from './findByName.js'
+import { asFunction, normalizeName } from './utils.js'
+
+export type EmojifyFormat = (
+  name: string,
+  part?: string,
+  input?: string,
+) => string
+
+export interface EmojifyOptions {
+  /**
+   * The string to fallback to if an emoji was not found.
+   */
+  fallback?: ((part: string) => string) | string
+
+  /**
+   * Adds a middleware layer to modify each matched emoji after parsing.
+   */
+  format?: EmojifyFormat
+}
+
+/**
+ * Parse all markdown-encoded emojis in a string.
+ */
+export const emojify = (
+  input: string,
+  { fallback, format = name => name }: EmojifyOptions = {},
+) => {
+  const fallbackFunction =
+    fallback === undefined ? fallback : asFunction(fallback)
+
+  is.assert.string(input)
+  is.assert.any([is.default.undefined, is.default.function_], fallbackFunction)
+  is.assert.function_(format)
+
+  return input.replace(/:[\w\-+]+:/g, part => {
+    const found = findByName(part)
+    if (found) {
+      return format(found.emoji, part, input)
+    }
+
+    if (fallbackFunction) {
+      return format(fallbackFunction(normalizeName(part)))
+    }
+
+    return format(part)
+  })
+}

package/src/emojilib.d.ts

@@ -0,0 +1,4 @@
+// Types for emojilib@v2
+declare module 'emojilib' {
+  export const lib: Record<string, { char: string }>
+}

package/src/find.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+
+import { find } from './find.js'
+
+describe('find', () => {
+  it('returns an emoji when given a name', () => {
+    expect(find('heart')).toEqual({ emoji: '❤️', key: 'heart' })
+  })
+
+  it('returns an emoji when given a :name:', () => {
+    expect(find(':heart:')).toEqual({ emoji: '❤️', key: 'heart' })
+  })
+
+  it('returns an emoji when given a code', () => {
+    expect(find('❤')).toEqual({ emoji: '❤', key: 'heart' })
+  })
+
+  it('returns the base emoji when given an alternate emoji code', () => {
+    expect(find('❤️')).toEqual({ emoji: '❤', key: 'heart' })
+  })
+
+  it('returns undefined when given an unknown name', () => {
+    expect(find('unknown_emoji')).toBeUndefined()
+  })
+
+  it('returns undefined when given an unknown :name:', () => {
+    expect(find('unknown_emoji')).toBeUndefined()
+  })
+})

package/src/find.ts

@@ -0,0 +1,9 @@
+import { findByCode } from './findByCode.js'
+import { findByName } from './findByName.js'
+
+/**
+ * Get the name and character of an emoji.
+ */
+export const find = (codeOrName: string) => {
+  return findByCode(codeOrName) ?? findByName(codeOrName)
+}

package/src/findByCode.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { findByCode } from './findByCode.js'
+
+describe('findByCode', () => {
+  it('returns undefined when given a name', () => {
+    expect(findByCode('heart')).toBeUndefined()
+  })
+
+  it('returns undefined when given a :name:', () => {
+    expect(findByCode(':heart:')).toBeUndefined()
+  })
+
+  it('returns the emoji when given an emoji code', () => {
+    expect(findByCode('❤')).toEqual({ emoji: '❤', key: 'heart' })
+  })
+
+  it('returns the base emoji when given an alternate emoji code', () => {
+    expect(findByCode('❤️')).toEqual({ emoji: '❤', key: 'heart' })
+  })
+})

package/src/findByCode.ts

@@ -0,0 +1,13 @@
+import { assert } from '@sindresorhus/is'
+
+import { emojiNamesByCode } from './data.js'
+import { normalizeCode } from './utils.js'
+
+export const findByCode = (code: string) => {
+  assert.string(code)
+
+  const emojiNormalized = normalizeCode(code)
+  const key = emojiNamesByCode.get(emojiNormalized)
+
+  return key ? { emoji: emojiNormalized, key } : undefined
+}

package/src/findByName.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+
+import { findByName } from './findByName.js'
+
+describe('findByName', () => {
+  it('returns an emoji when given a name', () => {
+    expect(findByName('heart')).toEqual({ emoji: '❤️', key: 'heart' })
+  })
+
+  it('returns an emoji when given a :name:', () => {
+    expect(findByName(':heart:')).toEqual({ emoji: '❤️', key: 'heart' })
+  })
+
+  it('returns undefined when given an emoji code', () => {
+    expect(findByName('❤')).toBeUndefined()
+  })
+
+  it('returns undefined when given an alternate emoji code', () => {
+    expect(findByName('❤️')).toBeUndefined()
+  })
+
+  it('returns undefined when given an unknown name', () => {
+    expect(findByName('unknown_emoji')).toBeUndefined()
+  })
+
+  it('returns undefined when given an unknown :name:', () => {
+    expect(findByName('unknown_emoji')).toBeUndefined()
+  })
+})

package/src/findByName.ts

@@ -0,0 +1,13 @@
+import { assert } from '@sindresorhus/is'
+
+import { emojiCodesByName } from './data.js'
+import { normalizeName } from './utils.js'
+
+export const findByName = (name: string) => {
+  assert.string(name)
+
+  const nameNormalized = normalizeName(name)
+  const emoji = emojiCodesByName.get(nameNormalized)
+
+  return emoji ? { emoji, key: nameNormalized } : undefined
+}

package/src/get.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { get } from './get.js'
+
+describe('get', () => {
+  it('returns an emoji code when given a string', () => {
+    expect(get('coffee')).toBe('☕')
+  })
+
+  it('returns the contained emoji code when given markdown emoji', () => {
+    expect(get(':coffee:')).toBe('☕')
+  })
+
+  it('returns undefined when given an emoji', () => {
+    expect(get('👯')).toBeUndefined()
+  })
+
+  it('returns undefined when given an unknown word', () => {
+    expect(get('unknown')).toBeUndefined()
+  })
+})

package/src/get.ts

@@ -0,0 +1,13 @@
+import { assert } from '@sindresorhus/is'
+
+import { emojiCodesByName } from './data.js'
+import { normalizeName } from './utils.js'
+
+/**
+ * Get an emoji from an emoji name.
+ */
+export const get = (codeOrName: string) => {
+  assert.string(codeOrName)
+
+  return emojiCodesByName.get(normalizeName(codeOrName))
+}

package/src/has.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+
+import { has } from './has.js'
+
+describe('has', () => {
+  it('returns true when given an emoji', () => {
+    expect(has('☕')).toBe(true)
+  })
+
+  it('returns true when given the name of an emoji', () => {
+    expect(has('coffee')).toBe(true)
+  })
+
+  it('returns true when given a markdown emoji name', () => {
+    expect(has(':coffee:')).toBe(true)
+  })
+
+  it('returns false when given unrelated text', () => {
+    expect(has('nonexistent')).toBe(false)
+  })
+
+  it('returns false when given an unknown markdown name', () => {
+    expect(has(':nonexistent:')).toBe(false)
+  })
+
+  it('returns true when given a emoji in base form', () => {
+    expect(has('❤️')).toBe(true)
+  })
+
+  it('returns true when given an emoji in code text form', () => {
+    expect(has('❤')).toBe(true)
+  })
+
+  it('returns false when given multiple emoji codes', () => {
+    expect(has('🍕❤️‍💋‍☕')).toBe(false)
+  })
+})

package/src/has.ts

@@ -0,0 +1,16 @@
+import { assert } from '@sindresorhus/is'
+
+import { emojiCodesByName, emojiNamesByCode } from './data.js'
+import { normalizeCode, normalizeName } from './utils.js'
+
+/**
+ * Check if this library supports a specific emoji.
+ */
+export const has = (codeOrName: string) => {
+  assert.string(codeOrName)
+
+  return (
+    emojiCodesByName.has(normalizeName(codeOrName)) ||
+    emojiNamesByCode.has(normalizeCode(codeOrName))
+  )
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './emojify.js'
+export * from './find.js'
+export * from './get.js'
+export * from './has.js'
+export * from './random.js'
+export * from './replace.js'
+export * from './search.js'
+export * from './strip.js'
+export * from './unemojify.js'
+export * from './which.js'

package/src/random.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest'
+
+import { get } from './get.js'
+import { has } from './has.js'
+import { random } from './random.js'
+
+describe('random', () => {
+  it('returns a random emoji and the corresponding key', () => {
+    const result = random()
+
+    expect(has(result.name)).toBe(true)
+    expect(result.emoji).toBe(get(result.name))
+  })
+})

package/src/random.ts

@@ -0,0 +1,10 @@
+import { emojiData } from './data.js'
+import { randomItem } from './utils.js'
+
+/**
+ * Get a random emoji.
+ */
+export const random = () => {
+  const [name, emoji] = randomItem(emojiData)
+  return { emoji, name }
+}

package/src/replace.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+
+import { replace } from './replace.js'
+
+describe('replace', () => {
+  it('returns an empty string when given an empty string', () => {
+    expect(replace('', 'b')).toBe('')
+  })
+
+  it('returns the input text when given text without emojis', () => {
+    expect(replace('no emojis', 'b')).toBe('no emojis')
+  })
+
+  it('returns a single emoji replacement when given text with one emoji', () => {
+    expect(replace('a ☕ c', 'b')).toBe('a bc')
+  })
+
+  it('returns multiple emoji replacement when given text with multiple emojis', () => {
+    expect(replace('a ☕ c 🍕 d', 'b')).toBe('a bc bd')
+  })
+
+  it('preserves spaces around emojis when preserveSpaces is true', () => {
+    expect(replace('a ☕ c 🍕 d', 'b', { preserveSpaces: true })).toBe(
+      'a b c b d',
+    )
+  })
+
+  it('replaces with the replacer when given a replacer', () => {
+    expect(replace('a 🌭 c', ({ emoji }) => `>${emoji}<`)).toBe('a >🌭<c')
+  })
+
+  it('replaces with the replacer and preserves spaces when given a replacer and preserveSpaces', () => {
+    expect(
+      replace('a 🌭 c', ({ emoji }) => `>${emoji}<`, {
+        preserveSpaces: true,
+      }),
+    ).toBe('a >🌭< c')
+  })
+
+  it('calls the replacer again when given multiple emojis', () => {
+    expect(
+      replace(
+        'a 🌭 b 🌭 🍵☕ c',
+        (() => {
+          let counter = 0
+          const letters = ['w', 'x', 'y', 'z']
+          return () => letters[counter++]
+        })(),
+      ),
+    ).toBe('a wb xyzc') // cspell:disable-line
+  })
+
+  it('strips complex emojis', () => {
+    expect(replace('before 👩‍❤️‍💋‍👩 after', '')).toBe('before after')
+  })
+
+  it('strips flag emojis', () => {
+    expect(replace('There is no flag 🇲🇽', '')).toBe('There is no flag ')
+  })
+
+  it('ignores known existing complex emojis', () => {
+    expect(replace('Some 🍕❤️‍💋‍☕ emoji', '')).toBe('Some ❤️‍💋‍☕ emoji')
+  })
+})

package/src/replace.ts

@@ -0,0 +1,46 @@
+import { assert } from '@sindresorhus/is'
+
+import { Emoji } from './data.js'
+import { findByCode } from './findByCode.js'
+import { asFunction, charRegexMatcher } from './utils.js'
+
+export type ReplaceReplacement = (
+  emoji: Emoji,
+  index: number,
+  string: string,
+) => string
+
+/**
+ * Replace the emojis in a string.
+ */
+export const replace = (
+  input: string,
+  replacement: ReplaceReplacement | string,
+  { preserveSpaces = false } = {},
+) => {
+  const replace = asFunction(replacement)
+
+  assert.string(input)
+  assert.function_(replace)
+  assert.boolean(preserveSpaces)
+
+  const characters = input.match(charRegexMatcher)
+  if (characters === null) {
+    return input
+  }
+
+  return characters
+    .map((character, index) => {
+      const found = findByCode(character)
+      if (!found) {
+        return character
+      }
+
+      if (!preserveSpaces && characters[index + 1] === ' ') {
+        characters[index + 1] = ''
+      }
+
+      return replace(found, index, input)
+    })
+    .join('')
+}

package/src/search.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest'
+
+import { search } from './search.js'
+
+describe('search', () => {
+  it('returns a single pair when given a one-of emoji name', () => {
+    expect(search('100')).toEqual([{ emoji: '💯', name: '100' }])
+  })
+
+  it('returns a single pair when given one-of emoji name as regular expression', () => {
+    expect(search(/100/)).toEqual([{ emoji: '💯', name: '100' }])
+  })
+
+  it('returns multiple emojis when given a common substring', () => {
+    expect(search('cartwheel')).toEqual([
+      {
+        emoji: '🤸‍♀️',
+        name: 'woman_cartwheeling',
+      },
+      {
+        emoji: '🤸‍♂️',
+        name: 'man_cartwheeling',
+      },
+    ])
+  })
+
+  it('returns multiple emojis when given a common regular expression', () => {
+    expect(search(/cartwheel/)).toEqual([
+      {
+        emoji: '🤸‍♀️',
+        name: 'woman_cartwheeling',
+      },
+      {
+        emoji: '🤸‍♂️',
+        name: 'man_cartwheeling',
+      },
+    ])
+  })
+
+  it('should match when you include the colon', () => {
+    expect(search(':cartwheel:')).toEqual([
+      {
+        emoji: '🤸‍♀️',
+        name: 'woman_cartwheeling',
+      },
+      {
+        emoji: '🤸‍♂️',
+        name: 'man_cartwheeling',
+      },
+    ])
+  })
+
+  it('should match when you include the colon in the regular expression', () => {
+    expect(search(/:cartwheel:/)).toEqual([
+      {
+        emoji: '🤸‍♀️',
+        name: 'woman_cartwheeling',
+      },
+      {
+        emoji: '🤸‍♂️',
+        name: 'man_cartwheeling',
+      },
+    ])
+  })
+
+  it('returns an empty array when no matching emojis are found for a string search', () => {
+    expect(search('notAnEmoji')).toEqual([])
+  })
+
+  it('returns an empty array when no matching emojis are found for a regular expression search', () => {
+    expect(search(/notAnEmoji/)).toEqual([])
+  })
+})

package/src/search.ts

@@ -0,0 +1,24 @@
+import is, { assert } from '@sindresorhus/is'
+
+import { emojiData } from './data.js'
+import { normalizeName } from './utils.js'
+
+/**
+ * Search for emojis containing the provided name or pattern in their name.
+ */
+export const search = (keyword: RegExp | string) => {
+  assert.any([is.default.string, is.default.regExp], keyword)
+
+  if (is.default.string(keyword)) {
+    keyword = normalizeName(keyword)
+  }
+
+  if (is.default.regExp(keyword)) {
+    const normalizedPattern = normalizeName(keyword.source)
+    keyword = new RegExp(normalizedPattern)
+  }
+
+  return emojiData
+    .filter(([name]) => name.match(keyword))
+    .map(([name, emoji]) => ({ emoji, name }))
+}

package/src/strip.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest'
+
+import { strip } from './strip.js'
+
+describe('strip', () => {
+  it('returns an empty string when given an empty string', () => {
+    expect(strip('')).toBe('')
+  })
+
+  it('returns an the input string when given a string with no emojis', () => {
+    expect(strip('abc')).toBe('abc')
+  })
+
+  it('returns an input string with an emoji removed when given an input string with one emoji', () => {
+    expect(strip('a ☕ c')).toBe('a c')
+  })
+
+  it('returns an input string with multiple emojis removed when given an input string with multiple emojis', () => {
+    expect(strip('a ☕ b 🍕 c')).toBe('a b c')
+  })
+
+  it('preserves spaces around emoji when preserveSpaces is true', () => {
+    expect(strip('a ☕ c', { preserveSpaces: true })).toBe('a  c')
+  })
+})

package/src/strip.ts

@@ -0,0 +1,14 @@
+import { replace } from './replace.js'
+
+export interface StripOptions {
+  /**
+   * Whether to keep the extra space after a stripped emoji.
+   */
+  preserveSpaces?: boolean
+}
+
+/**
+ * Remove all the emojis from a string.
+ */
+export const strip = (input: string, { preserveSpaces }: StripOptions = {}) =>
+  replace(input, '', { preserveSpaces })

package/src/unemojify.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+
+import { unemojify } from './unemojify.js'
+
+describe('unemojify', () => {
+  it('returns a blank string when given a blank string', () => {
+    expect(unemojify('')).toBe('')
+  })
+
+  it('returns a replaced emoji name when given a string with one emoji', () => {
+    expect(unemojify('a ☕ c')).toBe('a :coffee: c')
+  })
+
+  it('returns multiple replaced emoji names when given a string with multiple emojis', () => {
+    expect(unemojify('a ☕ 🌭 c')).toBe('a :coffee: :hotdog: c')
+  })
+
+  it('returns a complex emoji name when given a complex emoji:', () => {
+    expect(unemojify('before 👩‍❤️‍💋‍👩 after')).toBe(
+      'before :couplekiss_woman_woman: after',
+    )
+  })
+
+  it('parses emojis with names next to non-space characters', () => {
+    expect(unemojify('I ❤️  ☕️! -  😯⭐️😍  ::: test : : 👍+')).toBe(
+      'I :heart:  :coffee:! -  :hushed::star::heart_eyes:  ::: test : : :+1:+',
+    )
+  })
+
+  it('ignores only unknown emoji when given a string with some valid, some unknown emojis', () => {
+    // Emoji :melting_face: (U+1FAE0) Unicode 14.0 draft: https://emojipedia.org/unicode-14.0
+    expect(unemojify('I ⭐️ :another_one: 🫠')).toBe(
+      'I :star: :another_one: 🫠',
+    )
+  })
+
+  // see issue #21
+  it('should parse flags correctly', () => {
+    expect(unemojify('The flags of 🇲🇽 and 🇲🇦 are not the same')).toBe(
+      'The flags of :mexico: and :morocco: are not the same',
+    )
+  })
+})

package/src/unemojify.ts

@@ -0,0 +1,20 @@
+import { assert } from '@sindresorhus/is'
+
+import { charRegexMatcher } from './utils.js'
+import { which } from './which.js'
+
+/**
+ * Convert all emojis in a string to their markdown-encoded counterparts.
+ */
+export const unemojify = (input: string) => {
+  assert.string(input)
+
+  const characters = input.match(charRegexMatcher)
+  if (characters === null) {
+    return input
+  }
+
+  return characters
+    .map(character => which(character, { markdown: true }) ?? character)
+    .join('')
+}