@splendidlabz/utils 1.11.2 → 1.11.4

package/src/lib/style/index.js

@@ -1,13 +0,0 @@
-import { toKebab } from '../strings/convert-case/convert-case.js'
-
-export function toStyleString(style) {
-  if (!style) return null
-  if (typeof style === 'string') return style
-  return Object.entries(style)
-    .map(([k, v]) => {
-      if (k.startsWith('--')) return `${k}:${v}`
-      else return `${toKebab(k)}:${v}`
-    })
-    .join('; ')
-    .concat(';')
-}

package/src/lib/symbols/index.js

@@ -1 +0,0 @@
-export * from './symbols.js'

package/src/lib/symbols/symbols.js

@@ -1,9 +0,0 @@
-export function getSymbol(object, description) {
-  return Object.getOwnPropertySymbols(object).find(
-    s => s.description === description,
-  )
-}
-
-export function getSymbolValue(object, description) {
-  return object[getSymbol(object, description)]
-}

package/src/node/dirname.js

@@ -1,17 +0,0 @@
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-/**
- * Returns __dirname
- * @param url — import.meta.url
- * @returns
- */
-export function __dirname(url) {
-  if (!url) throw Error("Please provide 'import.meta.url' to dirname")
-  return path.dirname(fileURLToPath(url))
-}
-
-// Just an alias
-export function dirname(url) {
-  return __dirname(url)
-}

package/src/node/file-cache.js

@@ -1,184 +0,0 @@
-import fs from 'fs/promises'
-import { glob } from 'glob'
-import path from 'node:path'
-import { sort } from '../lib/arrays/index.js'
-
-/**
- * Resolves a path to an absolute path, handling both absolute and relative paths
- * @param {string} dirPath - Absolute or relative path to directory
- * @returns {string} Absolute path
- */
-function resolveDirPath(dirPath) {
-  return path.isAbsolute(dirPath) ? dirPath : path.join(process.cwd(), dirPath)
-}
-
-/**
- * Creates a file cache instance for managing cached files in a directory
- * @param {string} dir - Absolute or relative path to cache directory
- * @returns {Promise<object>} Cache instance
- * @property {function(string): Promise<number>} cacheAt - Returns the cached file's modified timestamp, or directory's last modified time if no file specified
- * @property {function(string): string} getAbsPath - Returns absolute path for a file in cache
- * @property {function(string): Promise<boolean>} hasFile - Checks if a file exists in cache
- * @property {function(string): Promise<Buffer|undefined>} loadFile - Loads file contents from cache
- * @property {function(string, string|Buffer): Promise<void>} saveFile - Saves data to cache file
- * @property {function(string): Promise<object>} loadJSON - Loads and parses JSON from cache file
- * @property {function(string, object): Promise<void>} saveJSON - Saves object as JSON to cache file
- */
-export async function createCache(dir) {
-  const absDirpath = resolveDirPath(dir)
-  await fs.mkdir(absDirpath, { recursive: true })
-
-  return {
-    async cacheAt(file) {
-      if (file) {
-        // Return the cached file's modified timestamp
-        const absFilepath = path.join(absDirpath, file)
-        try {
-          const stat = await fs.stat(absFilepath)
-          return stat.mtimeMs
-        } catch (error) {
-          return 0
-        }
-      } else {
-        // Return the last modified timestamp of the cache directory
-        return getLastModifiedTime(absDirpath + '/**/*')
-      }
-    },
-
-    getAbsPath(file) {
-      return path.join(absDirpath, file)
-    },
-
-    async hasFile(file) {
-      const absFilepath = path.join(absDirpath, file)
-      try {
-        await fs.stat(absFilepath)
-        return true
-      } catch (e) {
-        return false
-      }
-    },
-
-    async loadFile(file) {
-      try {
-        const absFilepath = path.join(absDirpath, file)
-        return fs.readFile(absFilepath)
-      } catch (error) {
-        console.warn(`File not found: ${file}`)
-      }
-    },
-
-    async saveFile(file, data) {
-      const absfilepath = path.join(absDirpath, file)
-      await fs.writeFile(absfilepath, data)
-    },
-
-    async loadJSON(file) {
-      const data = await this.loadFile(file)
-      try {
-        return JSON.parse(data.toString())
-      } catch (err) {
-        console.warn(`Error parsing JSON: ${file}`)
-        return {}
-      }
-    },
-
-    async saveJSON(file, data) {
-      await this.saveFile(file, JSON.stringify(data))
-    },
-  }
-}
-
-/**
- * Legacy file cache API for managing a single cached file
- * @param {Object} options
- * @param {string} options.dir - Absolute or relative path to cache directory
- * @param {string} options.file - Filename to cache
- * @returns {Promise<{
- *   modifiedAt: number,
- *   load: () => Promise<Buffer>,
- *   save: (data: string|Buffer) => Promise<void>,
- *   loadJSON: () => Promise<object>,
- *   saveJSON: (data: object) => Promise<void>
- * }>}
- */
-export async function fileCache({ dir, file }) {
-  // Makes the path if it doesn't exist
-  const absDirpath = resolveDirPath(dir)
-  await fs.mkdir(absDirpath, { recursive: true })
-  const cachePath = path.join(absDirpath, `${file}`)
-
-  let modifiedAt = 0
-
-  try {
-    const stat = await fs.stat(cachePath)
-    modifiedAt = stat.mtimeMs
-  } catch (error) {} // Silent error
-
-  return {
-    modifiedAt,
-
-    async load() {
-      return fs.readFile(cachePath)
-    },
-
-    async save(data) {
-      await fs.writeFile(cachePath, data)
-    },
-
-    async loadJSON() {
-      const data = await fs.readFile(cachePath)
-      return JSON.parse(data.toString())
-    },
-    async saveJSON(data) {
-      await fs.writeFile(cachePath, JSON.stringify(data))
-    },
-  }
-}
-
-/**
- * Gets the most recent modification time of files matching the glob pattern
- * @param {string|string[]} globPath - Glob pattern(s) to match files
- * @returns {Promise<number>} Timestamp of most recently modified file, or 0 if no files found
- */
-export async function getLastModifiedTime(globPath) {
-  let files
-
-  if (typeof globPath === 'string') {
-    files = await glob(removeFirstSlash(globPath))
-  }
-
-  if (Array.isArray(globPath)) {
-    const a = await Promise.all(
-      globPath.map(path => glob(removeFirstSlash(path))),
-    )
-    files = a.flat()
-  }
-
-  const stats = await Promise.all(files.map(file => fs.stat(file)))
-  const timestamps = stats.map(stat => Number(stat.mtimeMs))
-
-  const sorted = sort(timestamps, { props: 'mtimeMs', reverse: true })
-  return sorted[0] || 0
-}
-
-/**
- * @deprecated Use getLastModifiedTime instead
- * @param {string|string[]} globPath - Glob pattern(s) to match files
- * @returns {Promise<number>} Timestamp of most recently modified file, or 0 if no files found
- */
-export async function getLatestModifiedTime(globPath) {
-  console.warn(
-    '`getLatestModifiedTime` has been renamed to `getLastModifiedTime` and will be deprecated in future versions. Please use `getLastModifiedTime` instead.',
-  )
-  return getLastModifiedTime(globPath)
-}
-
-/**
- * Removes leading slash from a path string
- * @param {string} x - Path string to process
- * @returns {string} Path without leading slash
- */
-export function removeFirstSlash(x) {
-  return x.startsWith('/') ? x.slice(1) : x
-}

package/src/node/file.js

@@ -1,13 +0,0 @@
-// Common FS stuff
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-export async function mkdir(path) {
-  return fs.mkdir(path, { recursive: true })
-}
-
-export async function copyFile(from, to) {
-  const dir = path.dirname(to)
-  await mkdir(dir)
-  await fs.copyFile(from, to)
-}

package/src/node/hash.js

@@ -1,5 +0,0 @@
-import crypto from 'node:crypto'
-
-export function sha256Hash(string) {
-  return crypto.createHash('sha256').update(string).digest('hex')
-}

package/src/node/index.js

@@ -1,7 +0,0 @@
-export * from './dirname.js'
-export * from './file-cache.js'
-export * from './hash.js'
-export * from './pkce.js'
-export * from './random-string.js'
-export * from './sanitize.js'
-export * from './uuid.js'

package/src/node/pkce.js

@@ -1,33 +0,0 @@
-// For Node only.
-// Check the utils version for browsers.
-import crypto from 'node:crypto'
-import { randomString } from './random-string.js'
-
-export async function PKCE() {
-  const codeVerifier = await randomString()
-  const codeChallenge = await getCodeChallenge(codeVerifier)
-
-  return {
-    state: await randomString(),
-    code_verifier: codeVerifier,
-    code_challenge: codeChallenge,
-    code_challenge_method: 'S256',
-  }
-}
-
-/**
- * Generates code challenge in node
- * @param {string} verifier
- * @returns string
- */
-async function getCodeChallenge(verifier) {
-  // Hash to code verifier with SHA-256
-  const hash = crypto.createHash('sha256').update(verifier).digest()
-
-  // // Base64url encode the hash
-  return hash
-    .toString('base64')
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=/g, '')
-}

package/src/node/random-string.js

@@ -1,10 +0,0 @@
-import crypto from 'node:crypto'
-
-export function randomString(length = 32) {
-  // Calculate bytes needed for desired character length
-  // Base64: 4 chars per 3 bytes, so we need ceil(length * 3 / 4) bytes
-  // Add extra bytes to ensure we have enough after encoding
-  const bytesNeeded = Math.ceil((length * 3) / 4) + 3
-
-  return crypto.randomBytes(bytesNeeded).toString('base64').slice(0, length)
-}

package/src/node/random-string.test.js

@@ -1,15 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { randomString } from './random-string.js'
-
-describe('randomString', () => {
-  it('should generate a random string', () => {
-    const str = randomString(32)
-    expect(str).toBeDefined()
-    expect(str.length).toBe(32)
-
-    const str2 = randomString(40)
-    expect(str2).toBeDefined()
-    expect(str2.length).toBe(40)
-    expect(str2).not.toBe(str)
-  })
-})

package/src/node/sanitize.js

@@ -1,13 +0,0 @@
-import sanitizeHtml from 'sanitize-html'
-import { sanitize as sanitizeLib } from '../lib/form/sanitize.js'
-
-/**
- * Sanitizes values using sanitize-html
- * @param {*} value - Value to sanitize (string, array, or object)
- * @param {Object} [options={}] - sanitize-html options
- * @returns {*} Sanitized value
- * @throws {Error} If input is a string but sanitize-html fails
- */
-export function sanitize(value, options = {}) {
-  return sanitizeLib(value, { sanitizer: sanitizeHtml, ...options })
-}

package/src/node/sanitize.spec.js

@@ -1,142 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { sanitize } from './sanitize.js'
-
-describe('node sanitize', () => {
-  describe('sanitize', () => {
-    it('removes script tags', () => {
-      const input = '<script>alert("xss")</script>Hello'
-      expect(sanitize(input)).toBe('Hello')
-    })
-
-    it('allows safe HTML tags', () => {
-      const input = '<p>Hello <b>World</b></p>'
-      expect(sanitize(input, { allowedTags: ['b'] })).toBe('Hello <b>World</b>')
-    })
-
-    it('sanitizes unsafe attributes', () => {
-      const input = '<a href="javascript:alert(1)">Click me</a>'
-      expect(
-        sanitize(input, {
-          allowedTags: ['a'],
-          allowedAttributes: { a: ['href'] },
-        }),
-      ).toBe('<a>Click me</a>')
-    })
-
-    it('allows safe attributes', () => {
-      const input = '<a href="https://example.com">Safe link</a>'
-      expect(
-        sanitize(input, {
-          allowedTags: ['a'],
-          allowedAttributes: { a: ['href'] },
-        }),
-      ).toBe('<a href="https://example.com">Safe link</a>')
-    })
-
-    it('sanitizes HTML in string values', () => {
-      const input = {
-        name: '<script>alert("xss")</script>John',
-        bio: '<p>Hello <b>World</b> <script>alert("xss")</script></p>',
-        link: '<a href="javascript:alert(1)">Click me</a>',
-        safeLink: '<a href="https://example.com">Safe link</a>',
-      }
-
-      const expected = {
-        name: 'John',
-        bio: 'Hello <b>World</b> ',
-        link: '<a>Click me</a>',
-        safeLink: '<a href="https://example.com">Safe link</a>',
-      }
-
-      expect(
-        sanitize(input, {
-          allowedTags: ['b', 'i', 'em', 'strong', 'a'],
-          allowedAttributes: { a: ['href'] },
-        }),
-      ).toEqual(expected)
-    })
-
-    it('sanitizes nested objects with HTML', () => {
-      const input = {
-        user: {
-          name: '<script>alert("xss")</script>John',
-          profile: {
-            bio: '<p>Hello <b>World</b></p>',
-            links: [
-              '<a href="javascript:alert(1)">Bad</a>',
-              '<a href="https://good.com">Good</a>',
-            ],
-          },
-        },
-      }
-
-      const expected = {
-        user: {
-          name: 'John',
-          profile: {
-            bio: 'Hello <b>World</b>',
-            links: ['<a>Bad</a>', '<a href="https://good.com">Good</a>'],
-          },
-        },
-      }
-
-      expect(
-        sanitize(input, {
-          allowedTags: ['b', 'i', 'em', 'strong', 'a'],
-          allowedAttributes: { a: ['href'] },
-        }),
-      ).toEqual(expected)
-    })
-
-    it('preserves non-string values and sanitizes arrays correctly', () => {
-      const input = {
-        name: '<script>alert("xss")</script>John',
-        age: 25,
-        active: true,
-        email: null,
-        role: undefined,
-        tags: ['<script>alert(1)</script>admin', 'user'],
-        numbers: [1, 2, 3],
-        mixed: ['<b>bold</b>', 42, null, '<script>alert(1)</script>text'],
-      }
-
-      const expected = {
-        name: 'John',
-        age: 25,
-        active: true,
-        email: null,
-        role: undefined,
-        tags: ['admin', 'user'],
-        numbers: [1, 2, 3],
-        mixed: ['<b>bold</b>', 42, null, 'text'],
-      }
-
-      expect(
-        sanitize(input, {
-          allowedTags: ['b', 'i', 'em', 'strong', 'a'],
-          allowedAttributes: { a: ['href'] },
-        }),
-      ).toEqual(expected)
-    })
-
-    it('allows custom sanitizer options', () => {
-      const input = {
-        content: '<p>Hello <span>World</span> <script>alert(1)</script></p>',
-      }
-
-      // Test with custom allowed tags
-      const withSpan = sanitize(input, {
-        allowedTags: ['b', 'i', 'em', 'strong', 'a', 'span'],
-        allowedAttributes: { a: ['href'] },
-      })
-      expect(withSpan.content).toBe('Hello <span>World</span> ')
-
-      // Test with no allowed tags
-      const noTags = sanitize(input, {
-        allowedTags: [],
-        allowedAttributes: { a: ['href'] },
-      })
-      expect(noTags.content).toBe('Hello World ')
-    })
-  })
-})

package/src/node/uuid.js

@@ -1,5 +0,0 @@
-import crypto from 'crypto'
-
-export function uuid() {
-  return crypto.randomUUID()
-}

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowJs": true,
-    "checkJs": true,
-    "declaration": true,
-    "emitDeclarationOnly": false,
-    "outDir": "./dist/temp",
-    "strict": false,
-    "noImplicitAny": false,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.js", "**/*.spec.js", "dist/**/*"]
-}

package/tsup.config.js

@@ -1,38 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig([
-  // ESM build
-  {
-    entry: 'src/**/*.js',
-    format: ['esm'],
-    outDir: 'dist/esm',
-    clean: true,
-    splitting: false,
-    sourcemap: false,
-    dts: false,
-    ignoreWatch: ['**/*.test.js', '**/*.spec.js'],
-  },
-  // CJS build
-  {
-    entry: 'src/**/*.js',
-    format: ['cjs'],
-    outDir: 'dist/cjs',
-    outExtension: () => ({ js: '.cjs' }),
-    clean: false,
-    splitting: false,
-    sourcemap: false,
-    dts: false,
-    ignoreWatch: ['**/*.test.js', '**/*.spec.js'],
-  },
-  // Types build
-  {
-    entry: 'src/**/*.js',
-    dts: {
-      only: true,
-    },
-    outDir: 'dist/types',
-    outExtension: () => ({ dts: '.d.cts' }),
-    clean: false,
-    ignoreWatch: ['**/*.test.js', '**/*.spec.js'],
-  },
-])

package/tsup.config.mjs

@@ -1,45 +0,0 @@
-import { glob } from 'glob'
-import { defineConfig } from 'tsup'
-
-function getEntryPoints() {
-  // Get all JS files except test files
-  return glob.sync('src/**/*.js', {
-    ignore: ['**/*.test.js', '**/*.spec.js'],
-  })
-}
-
-export default defineConfig([
-  // ESM build
-  {
-    entry: getEntryPoints(),
-    format: ['esm'],
-    outDir: 'dist/esm',
-    clean: true,
-    bundle: false,
-    splitting: false,
-    sourcemap: false,
-    dts: false,
-  },
-  // CJS build
-  {
-    entry: getEntryPoints(),
-    format: ['cjs'],
-    outDir: 'dist/cjs',
-    outExtension: () => ({ js: '.cjs' }),
-    clean: false,
-    bundle: false,
-    splitting: false,
-    sourcemap: false,
-    dts: false,
-  },
-  // Types build
-  {
-    entry: getEntryPoints(),
-    dts: {
-      only: true,
-    },
-    outDir: 'dist/types',
-    outExtension: () => ({ dts: '.d.cts' }),
-    clean: false,
-  },
-])