@edgeandnode/eds-utils 1.0.0

package/src/getKey.ts

@@ -0,0 +1,37 @@
+const refMap = new WeakMap<object, string>()
+let refCounter = 0
+
+/**
+ * Generates a stable, unique string key for any JS value.
+ *
+ * - null / undefined => 'null' / 'undefined'
+ * - string / number / boolean => `${type}:${value}` (e.g. 'string:hello', 'number:42',
+ *   'boolean:false')
+ * - registered symbols (`Symbol.for('foo')`) => 'symbol:foo'
+ * - objects / functions / non-registered symbols => one-time ID (e.g. 'ref:1', 'ref:2', etc.)
+ *
+ * @param value - Any JavaScript value.
+ * @returns A string that uniquely and consistently identifies the value.
+ */
+export function getKey(value: unknown): string {
+  if (value === null) return 'null'
+  if (value === undefined) return 'undefined'
+
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return `${typeof value}:${value}`
+  }
+
+  if (typeof value === 'symbol') {
+    const registryKey = Symbol.keyFor(value)
+    if (registryKey !== undefined) {
+      return `symbol:${registryKey}`
+    }
+  }
+
+  let id = refMap.get(value)
+  if (!id) {
+    id = `ref:${++refCounter}`
+    refMap.set(value, id)
+  }
+  return id
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from './constants.ts'
+export * from './types.ts'
+export { bigIntToNumber, type BigIntToNumberOptions } from './bigIntToNumber.ts'
+export { camelToKebab } from './camelToKebab.ts'
+export { createIdenticon } from './createIdenticon.ts'
+export { formatAddress } from './formatAddress.ts'
+export { formatBigInt, type BigIntFormatOptions } from './formatBigInt.ts'
+export { getKey } from './getKey.ts'
+export { loremIpsum } from './loremIpsum.ts'
+export { numberToBigInt, type NumberToBigIntOptions } from './numberToBigInt.ts'
+export { parseBigInt, type ParseBigIntOptions } from './parseBigInt.ts'
+export { parseNumber, type ParseNumberOptions } from './parseNumber.ts'
+export { sliceWrap } from './sliceWrap.ts'

package/src/loremIpsum.ts

@@ -0,0 +1,143 @@
+import { sliceWrap } from './sliceWrap.ts'
+
+/**
+ * Generates lorem ipsum text.
+ *
+ * @param {number} [count=4] - The number of words, sentences, or paragraphs to generate. Default is
+ *   `4`
+ * @param {'words' | 'sentences' | 'paragraphs'} [units='sentences'] - The units to generate.
+ *   Default is `'sentences'`
+ * @returns {string} The generated text.
+ */
+export function loremIpsum(
+  count: number = 4,
+  units: 'words' | 'sentences' | 'paragraphs' = 'sentences',
+): string {
+  switch (units) {
+    case 'words':
+      return wordsToSentence(sliceWrap(WORDS, 0, count))
+    case 'sentences':
+      return sliceWrap(SENTENCES, 0, count)
+        .map((sentence) => wordsToSentence(sentence.words))
+        .join(' ')
+    case 'paragraphs':
+      return sliceWrap(PARAGRAPHS, 0, count)
+        .map((paragraph) =>
+          paragraph.sentences.map((sentence) => wordsToSentence(sentence.words)).join(' '),
+        )
+        .join('\n')
+  }
+}
+
+function wordsToSentence(words: string[]) {
+  let sentence = ''
+  for (const word of words) {
+    if (sentence.length > 0) sentence += ' '
+    sentence += word
+  }
+  if (sentence.endsWith(',')) {
+    sentence = sentence.slice(0, -1)
+  }
+  if (sentence.length > 0 && !sentence.endsWith('.')) {
+    sentence += '.'
+  }
+  return sentence
+}
+
+const LOREM_IPSUM = {
+  paragraphs: [
+    {
+      sentences: [
+        {
+          words: [
+            'Lorem',
+            'ipsum',
+            'dolor',
+            'sit',
+            'amet,',
+            'consectetur',
+            'adipiscing',
+            'elit,',
+            'sed',
+            'do',
+            'eiusmod',
+            'tempor',
+            'incididunt',
+            'ut',
+            'labore',
+            'et',
+            'dolore',
+            'magna',
+            'aliqua.',
+          ],
+        },
+        {
+          words: [
+            'Ut',
+            'enim',
+            'ad',
+            'minim',
+            'veniam,',
+            'quis',
+            'nostrud',
+            'exercitation',
+            'ullamco',
+            'laboris',
+            'nisi',
+            'ut',
+            'aliquip',
+            'ex',
+            'ea',
+            'commodo',
+            'consequat.',
+          ],
+        },
+        {
+          words: [
+            'Duis',
+            'aute',
+            'irure',
+            'dolor',
+            'in',
+            'reprehenderit',
+            'in',
+            'voluptate',
+            'velit',
+            'esse',
+            'cillum',
+            'dolore',
+            'eu',
+            'fugiat',
+            'nulla',
+            'pariatur.',
+          ],
+        },
+        {
+          words: [
+            'Excepteur',
+            'sint',
+            'occaecat',
+            'cupidatat',
+            'non',
+            'proident,',
+            'sunt',
+            'in',
+            'culpa',
+            'qui',
+            'officia',
+            'deserunt',
+            'mollit',
+            'anim',
+            'id',
+            'est',
+            'laborum.',
+          ],
+        },
+      ],
+    },
+  ],
+}
+
+const PARAGRAPHS = LOREM_IPSUM.paragraphs
+const SENTENCES = PARAGRAPHS.flatMap((paragraph) => paragraph.sentences)
+const WORDS = SENTENCES.flatMap((sentence) => sentence.words)

package/src/numberToBigInt.ts

@@ -0,0 +1,38 @@
+import { parseBigInt } from './parseBigInt.ts'
+
+export interface NumberToBigIntOptions {
+  /**
+   * The number of digits starting from the right of the returned bigint to consider as decimal
+   * places.
+   *
+   * @default 18n
+   */
+  precision?: bigint | undefined
+}
+
+/**
+ * Converts a number to a bigint. Decimals to the right of `precision` are truncated.
+ *
+ * @param value - The number to convert to a bigint.
+ * @param options - Conversion options.
+ * @returns The bigint representation of `value`
+ */
+export function numberToBigInt(value: number, options?: NumberToBigIntOptions): bigint {
+  const { precision = 18n } = options ?? {}
+  if (precision < 0n) {
+    throw new Error(`[numberToBigInt] \`precision\` must be positive, got ${precision}`)
+  }
+  // If `value` has decimals and `precision` is at least 1, parse it as a string
+  if (value % 1 !== 0 && precision >= 1n) {
+    const parsedValue = parseBigInt(String(value), { precision })
+    if (parsedValue === null) {
+      throw new Error(
+        `[numberToBigInt] Failed to parse ${value} as a bigint with precision ${precision}`,
+      )
+    }
+    return parsedValue
+  } else {
+    const precisionFactor = 10n ** precision
+    return BigInt(Math.trunc(value)) * precisionFactor
+  }
+}

package/src/parseBigInt.ts

@@ -0,0 +1,51 @@
+export interface ParseBigIntOptions {
+  /**
+   * The number of digits starting from the right of the returned bigint to consider as decimal
+   * places.
+   *
+   * @default 18n
+   */
+  precision?: bigint | undefined
+  /**
+   * If true, requires exact match (no commas, no extra whitespace)
+   *
+   * @default false
+   */
+  strict?: boolean | undefined
+}
+
+/**
+ * Like `parseNumber()`, but returns a bigint instead of a number. Decimals to the right of
+ * `precision` are truncated.
+ *
+ * @param value - The string to parse as a bigint.
+ * @param options - Parsing options.
+ * @returns The bigint representation of `value`, or `null` if we failed to parse it.
+ */
+export function parseBigInt(value: string, options?: ParseBigIntOptions) {
+  const { precision = 18n, strict = false } = options ?? {}
+  if (precision < 0n) {
+    throw new Error(`[parseBigInt] \`precision\` must be positive, got ${precision}`)
+  }
+
+  const originalValue = value
+  const cleanedValue = value.replace(/,/g, '').trim()
+
+  if (strict && cleanedValue !== originalValue) return null
+  if (cleanedValue === '' || cleanedValue === '-' || cleanedValue === '.' || cleanedValue === '-.')
+    return null
+
+  const [integerPart, decimalPart = '', somethingAfterDecimalPart] = cleanedValue.split('.')
+  if (integerPart!.trim() !== integerPart) return null
+  if (decimalPart.trim() !== decimalPart) return null
+  if (somethingAfterDecimalPart !== undefined) return null
+
+  try {
+    const precisionNumber = Number(precision)
+    return BigInt(
+      `${integerPart}${decimalPart.slice(0, precisionNumber).padEnd(precisionNumber, '0')}`,
+    )
+  } catch {
+    return null
+  }
+}

package/src/parseNumber.ts

@@ -0,0 +1,24 @@
+export interface ParseNumberOptions {
+  /**
+   * If true, requires exact match (no commas, no extra whitespace)
+   *
+   * @default false
+   */
+  strict?: boolean | undefined
+}
+
+/**
+ * Parses a string value into a number, with optional strict mode.
+ *
+ * @param value - The string value to parse.
+ * @param options - Parsing options.
+ * @returns The parsed number, or null if parsing fails.
+ */
+export function parseNumber(value: string, options?: ParseNumberOptions) {
+  const { strict = false } = options ?? {}
+  const cleanedValue = value.replace(/,/g, '').trim()
+  if (cleanedValue === '' || (cleanedValue !== value && strict)) return null
+  const number = Number(cleanedValue)
+  if (!Number.isFinite(number) || (String(number) !== cleanedValue && strict)) return null
+  return number
+}

package/src/sliceWrap.ts

@@ -0,0 +1,9 @@
+/** Same as `array.slice(start, end)`, but wraps around the end of the array. */
+export function sliceWrap<T>(array: T[], start: number, end: number) {
+  if (array.length === 0) return []
+  const result: typeof array = []
+  for (let i = start; i < end; i++) {
+    result.push(array[i % array.length]!)
+  }
+  return result
+}

package/src/types.ts

@@ -0,0 +1,4 @@
+import type { SetNonNullable, SetRequired } from 'type-fest'
+
+export type DeepRecord<Value> = { [key: string]: Value | DeepRecord<Value> }
+export type SetRequiredNonNullable<T, K extends keyof T> = SetRequired<SetNonNullable<T, K>, K>