@loadsmart/loadsmart-ui 7.6.0 → 8.0.0-beta.1

package/src/utils/toolset/getID.ts

@@ -1,93 +0,0 @@
-import range from './range'
-
-const MAX_LENGTH = 15
-const INITIAL_LENGTH = 2
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-'
-
-/**
- *
- * @param {Object} options - Options
- * @param
- * @returns
- */
-export function IDGenerator({
-  maxIDLength,
-  initialIDLength,
-  alphabet,
-}: {
-  maxIDLength: number
-  initialIDLength: number
-  alphabet: string
-}): () => string {
-  let currentLength = initialIDLength
-
-  // eslint-disable-next-line prefer-const
-  let filledCharacters = [
-    ...(Array(maxIDLength - currentLength).fill(-1) as number[]),
-    ...(Array(currentLength).fill(0) as number[]),
-  ]
-
-  let availableIDs = range(initialIDLength, maxIDLength + 1).reduce(
-    // using arrangement with repetition formula
-    (acc: number, n: number) => acc + Math.pow(alphabet.length, n),
-    0
-  )
-
-  return function getID() {
-    if (availableIDs == 0) {
-      throw new Error(`No more IDs available with the provided alphabet and max length`)
-    }
-
-    availableIDs--
-    const newID = filledCharacters.slice(-1 * currentLength).map((at: number) => alphabet[at])
-
-    /**
-     * [0, 0, 0, 0]
-     *              ^ at
-     */
-    let at = filledCharacters.length
-
-    /**
-     * move to the left in the `filledCharacters` array if
-     * we have surpassed the last possible character in `alphabet`.
-     * That means:
-     * [0,0,0,(alphabet.length - 1)]
-     * Becomes:
-     * [0,0,1,0]
-     */
-
-    do {
-      at--
-      filledCharacters[at] = (filledCharacters[at] + 1) % alphabet.length
-    } while (filledCharacters[at] == 0 && at >= filledCharacters.length - currentLength)
-
-    /**
-     * if we moved to the left as much as `currentLength` allowed,
-     * and we have incremented as many times as we could, for each
-     * position so we're back to `0`, due to the module operation,
-     * i.e., if `currentLength = 3`, for example:
-     *
-     * [0, 0, 0, 0]
-     *     ^ currentLength
-     *  ^at
-     *
-     * So we need to increase `currentLength` to start incrementing from there:
-     * [0, 0, 0, 0]
-     *  ^ currentLength
-     */
-    if (filledCharacters.length - at > currentLength) {
-      currentLength++
-    }
-
-    return `genid-${newID.join('')}`
-  }
-}
-
-// this configuration is capable of generating 469172025408063600 different IDs.
-const getID = IDGenerator({
-  maxIDLength: MAX_LENGTH,
-  alphabet: ALPHABET,
-  initialIDLength: INITIAL_LENGTH,
-})
-
-export default getID

package/src/utils/toolset/getOrdinalSuffix.test.ts

@@ -1,27 +0,0 @@
-import { getOrdinalSuffix } from './getOrdinalSuffix'
-
-it('should return "st" for numbers ending with 1', () => {
-  expect(getOrdinalSuffix(1)).toBe('st')
-  expect(getOrdinalSuffix(101)).toBe('st')
-  expect(getOrdinalSuffix(1001)).toBe('st')
-})
-
-it('should return "nd" for numbers ending with 2', () => {
-  expect(getOrdinalSuffix(2)).toBe('nd')
-  expect(getOrdinalSuffix(102)).toBe('nd')
-  expect(getOrdinalSuffix(1002)).toBe('nd')
-})
-
-it('should return "rd" for numbers ending with 3', () => {
-  expect(getOrdinalSuffix(3)).toBe('rd')
-  expect(getOrdinalSuffix(103)).toBe('rd')
-  expect(getOrdinalSuffix(1003)).toBe('rd')
-})
-
-it('should return "th" for 0 and numbers higher than 3 but not ending with 1, 2 or 3', () => {
-  expect(getOrdinalSuffix(0)).toBe('th')
-  expect(getOrdinalSuffix(4)).toBe('th')
-  expect(getOrdinalSuffix(10)).toBe('th')
-  expect(getOrdinalSuffix(100)).toBe('th')
-  expect(getOrdinalSuffix(1000)).toBe('th')
-})

package/src/utils/toolset/getOrdinalSuffix.ts

@@ -1,15 +0,0 @@
-export const getOrdinalSuffix = (number: number): 'st' | 'nd' | 'rd' | 'th' => {
-  if (number % 10 === 1 && number !== 11) {
-    return 'st'
-  }
-
-  if (number % 10 === 2 && number !== 12) {
-    return 'nd'
-  }
-
-  if (number % 10 === 3 && number !== 13) {
-    return 'rd'
-  }
-
-  return 'th'
-}

package/src/utils/toolset/highlightMatch.test.tsx

@@ -1,32 +0,0 @@
-import React from 'react'
-import highlightMatch from './highlightMatch'
-
-describe('Match highligther', () => {
-  it('wraps a match inside a mark', () => {
-    expect(highlightMatch('Label', 'lab')).toEqual(
-      <>
-        {''}
-        <mark>Lab</mark>el
-      </>
-    )
-    expect(highlightMatch('Label', 'abe')).toEqual(
-      <>
-        L<mark>abe</mark>l
-      </>
-    )
-    expect(highlightMatch('Label', 'bel')).toEqual(
-      <>
-        La<mark>bel</mark>
-        {''}
-      </>
-    )
-    expect(highlightMatch('Label', 'xyz')).toEqual(<>Label</>)
-
-    /*
-     This can possibly happen in projects that don't use TypeScript or at runtime.
-     */
-    const nullAsString: string = null as unknown as string
-    expect(highlightMatch('Label', nullAsString)).toEqual(<>Label</>)
-    expect(highlightMatch(nullAsString, 'xyz')).toEqual(<>{null}</>)
-  })
-})

package/src/utils/toolset/highlightMatch.tsx

@@ -1,32 +0,0 @@
-import React from 'react'
-
-/**
- * A function that wraps a match into `mark` element to be highlighted.
- * @example
- *
- * @param {string} - label to be split
- * @param {string} - match to be found
- * @returns {ReactNode} - an element with marked match
- */
-export default function highlightMatch(str: string, match: string): JSX.Element {
-  if (str == null || match == null) {
-    return <>{str}</>
-  }
-
-  // the explicit coercion here ensures that we'll be dealing with strings even in vanilla JS code
-  const index = String(str).toLowerCase().indexOf(String(match).toLowerCase())
-
-  if (index === -1) return <>{str}</>
-
-  const pre = str.slice(0, index)
-  const mid = str.slice(index, index + match.length)
-  const post = str.slice(index + match.length)
-
-  return (
-    <>
-      {pre}
-      <mark>{mid}</mark>
-      {post}
-    </>
-  )
-}

package/src/utils/toolset/interleave.test.ts

@@ -1,40 +0,0 @@
-import interleave from './interleave'
-import generator from '../../tests/generator'
-
-function generateArray() {
-  return generator.array(() => generator.natural({ min: 1, max: 999 }), 3)
-}
-
-describe('interleave', () => {
-  it('returns an empty array if both args are empty arrays', () => {
-    expect(interleave([], [])).toEqual([])
-  })
-
-  it('returns the first array if the second one is empty', () => {
-    const array1: Array<number> = generateArray()
-    const array2: Array<number> = []
-
-    expect(interleave(array1, array2)).toEqual(array1)
-  })
-
-  it('returns the second array if the fisrt one is empty', () => {
-    const array1: Array<number> = []
-    const array2: Array<number> = generateArray()
-
-    expect(interleave(array1, array2)).toEqual(array2)
-  })
-
-  it('interleaves items from both arrays', () => {
-    const array1: Array<number> = generateArray()
-    const array2: Array<number> = generateArray()
-
-    expect(interleave(array1, array2)).toEqual([
-      array1[0],
-      array2[0],
-      array1[1],
-      array2[1],
-      array1[2],
-      array2[2],
-    ])
-  })
-})

package/src/utils/toolset/interleave.ts

@@ -1,23 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import flatten from './flatten'
-import isEmpty from './isEmpty'
-import toArray from './toArray'
-
-// TODO: add this helper to @loadsmart/utils
-
-function interleave<T>(array1: Array<T>, array2: Array<T>): T[] {
-  const safeArray1 = toArray(array1)
-  const safeArray2 = toArray(array2)
-
-  if (isEmpty(safeArray1) && isEmpty(safeArray2)) {
-    return []
-  } else if (isEmpty(safeArray1)) {
-    return safeArray2
-  } else if (isEmpty(safeArray2)) {
-    return safeArray1
-  }
-
-  return flatten(safeArray1.map((element, index) => [element, safeArray2[index]]))
-}
-
-export default interleave

package/src/utils/toolset/isEmpty.ts

@@ -1,2 +0,0 @@
-import { isEmpty } from 'lodash'
-export default isEmpty

package/src/utils/toolset/isThenable.test.ts

@@ -1,40 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-import { isThenable } from './isThenable'
-
-describe('isThenable', () => {
-  it('returns false when input is a number', () => {
-    expect(isThenable(2)).toBe(false)
-  })
-
-  it('returns false when input is null', () => {
-    expect(isThenable(null)).toBe(false)
-  })
-
-  it('returns false when input is undefined', () => {
-    expect(isThenable(undefined)).toBe(false)
-  })
-
-  it('returns false when input is a string', () => {
-    expect(isThenable('foo')).toBe(false)
-  })
-
-  it('returns false when input is a function', () => {
-    expect(isThenable(() => {})).toBe(false)
-  })
-
-  it('returns false when input is an object', () => {
-    expect(isThenable({})).toBe(false)
-  })
-
-  it('returns true when input is a Promise', () => {
-    expect(isThenable(new Promise(() => {}))).toBe(true)
-  })
-
-  it('returns true when input is a thenable object', () => {
-    expect(isThenable({ then: () => {} })).toBe(true)
-  })
-
-  it('returns false when input is not a thenable object', () => {
-    expect(isThenable({ then: 'foo' })).toBe(false)
-  })
-})

package/src/utils/toolset/isThenable.ts

@@ -1,14 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { isObject } from '@loadsmart/utils-object'
-import { isFunction } from '@loadsmart/utils-function'
-
-interface Thenable {
-  then(): any
-}
-
-// TODO: add this helper to @loadsmart/utils
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function isThenable(object: any): object is Thenable {
-  return isObject(object) && isFunction((object as Thenable)['then'])
-}

package/src/utils/toolset/keyboard.ts

@@ -1,50 +0,0 @@
-import toArray from './toArray'
-
-import type { KeyboardEvent } from 'react'
-
-// this is merely a helper for  key code names
-const SUPPORTED_KEYS = {
-  ALT: 'Alt',
-  ARROW_DOWN: 'ArrowDown',
-  ARROW_LEFT: 'ArrowLeft',
-  ARROW_RIGHT: 'ArrowRight',
-  ARROW_UP: 'ArrowUp',
-  CONTROL: 'Control',
-  ENTER: 'Enter',
-  ESCAPE: 'Escape',
-  SHIFT: 'Shift',
-  SPACE: ' ',
-  TAB: 'Tab',
-  E_LOWERCASE: 'e',
-  DOT: '.',
-  PLUS: '+',
-  MINUS: '-',
-}
-
-export type SupportedKey = keyof typeof SUPPORTED_KEYS
-
-// Based on https://github.com/downshift-js/downshift/blob/26c93a539dad09e41adba69ddc3a7d7ecccfc8bb/src/utils.js#L285
-export function getKeyboardKey(e: KeyboardEvent): KeyboardEvent['key'] {
-  // IE
-  if (e.keyCode >= 37 && e.keyCode <= 40 && e.key.indexOf('Arrow') !== 0) {
-    return `Arrow${e.key}`
-  }
-
-  return e.key
-}
-
-function KeyboardKey(e: KeyboardEvent): {
-  is(otherKeys: SupportedKey | SupportedKey[]): boolean
-} {
-  const key = getKeyboardKey(e)
-
-  return {
-    is(otherKeys: SupportedKey | SupportedKey[]) {
-      const expectedKeys = toArray(otherKeys).map((otherKey) => SUPPORTED_KEYS[otherKey])
-
-      return toArray(expectedKeys).includes(key)
-    },
-  }
-}
-
-export default KeyboardKey

package/src/utils/toolset/omit.ts

@@ -1,2 +0,0 @@
-import { omit } from 'lodash'
-export default omit

package/src/utils/toolset/pluralize.ts

@@ -1,16 +0,0 @@
-/**
- * Helper that returns the plural form if count is different than 1, otherwise the singular one.
- * @example
- * let total = 3
- * `Item${pluralize(total)}` // "Items"
- * `Child${pluralize(total, 'ren')}` // "Children"
- * `Pe${pluralize(total, 'ople', 'rson')}` // "People"
- * `${pluralize(total, 'People', 'Person')}` // "People"
- * @param count - total of items
- * @param plural - defaults to "s"
- * @param singular - defaults to ""
- * @returns plural or singular.
- */
-export default function pluralize(count: number, plural = 's', singular = ''): string {
-  return count !== 1 ? plural : singular
-}

package/src/utils/toolset/range.ts

@@ -1,2 +0,0 @@
-import { range } from 'lodash'
-export default range

package/src/utils/toolset/rem.ts

@@ -1,7 +0,0 @@
-export const BASE_PIXELS = 16
-
-function rem(valueInPixels: number | string, base = BASE_PIXELS): string {
-  return `${parseInt(String(valueInPixels), 10) / base}rem`
-}
-
-export default rem

package/src/utils/toolset/styledCompounds.ts

@@ -1,22 +0,0 @@
-import type { StyledComponent } from 'styled-components'
-
-/**
- * Helper that returns the plural form if count is different than 1, otherwise the singular one.
- * @example
- * const StyledParent = styled.div``
- * styledCompounds(StyledParent, { Child: (props) => <div /> })
- * <StyledParent.Child />
- * @param StyledComponent - Parent instance of a styled-component
- * @param compounds - Object with compound components
- * @returns Parent component with type-safe accessable compound components
- */
-export function styledCompounds<
-  A extends StyledComponent<React.ComponentType, Record<string, unknown>>,
-  B extends Record<string, unknown>
->(Parent: A, compounds: B): A & B {
-  Object.keys(compounds).forEach((key) => {
-    // @ts-expect-error StyledComponent is read-only
-    Parent[key] = compounds[key]
-  })
-  return Parent as A & B
-}

package/src/utils/toolset/toArray.ts

@@ -1,16 +0,0 @@
-import { isNil } from '@loadsmart/utils-object'
-
-// TODO: add this helper to @loadsmart/utils
-function toArray<T>(value: T | T[]): T[] {
-  if (isNil(value)) {
-    return []
-  }
-
-  if (Array.isArray(value)) {
-    return value
-  }
-
-  return [value]
-}
-
-export default toArray

package/src/utils/types/ColorScheme.ts

@@ -1,3 +0,0 @@
-type ColorScheme = 'dark' | 'light'
-
-export default ColorScheme

package/src/utils/types/EventLike.ts

@@ -1,11 +0,0 @@
-export interface EventLikeTarget<T> {
-  id?: number | string
-  name: string
-  value: T
-  type?: string
-  checked?: boolean
-}
-
-export default interface EventLike<T> {
-  target: EventLikeTarget<T>
-}

package/src/utils/types/InterpolatedStyle.ts

@@ -1,3 +0,0 @@
-import type { ThemeTokenValue } from 'theming'
-
-export type InterpolatedStyle = (ThemeTokenValue | ((...args: unknown[]) => ThemeTokenValue))[]

package/src/utils/types/Status.ts

@@ -1,8 +0,0 @@
-enum Status {
-  Success = 'success',
-  Danger = 'danger',
-  Warn = 'warn',
-  Neutral = 'neutral',
-}
-
-export default Status