@devthing/utils 0.0.1

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@devthing/utils",
+  "version": "0.0.1",
+  "main": "./index.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "postinstall": "bun scripts/generate-exports"
+  }
+}

package/scripts/generate-exports.ts

@@ -0,0 +1,44 @@
+import {readdir, writeFile} from 'node:fs/promises'
+import {resolve} from 'node:path'
+
+const packageRoot = resolve(import.meta.dir, '..')
+const srcDir = resolve(packageRoot, 'src')
+const outputFile = resolve(packageRoot, 'index.ts')
+
+const walk = async (dir: string, baseDir = dir): Promise<string[]> => {
+  const entries = await readdir(dir, {withFileTypes: true})
+  const files: string[] = []
+
+  for (const entry of entries) {
+    const fullPath = resolve(dir, entry.name)
+
+    if (entry.isDirectory()) {
+      files.push(...(await walk(fullPath, baseDir)))
+      continue
+    }
+
+    if (!entry.isFile()) {
+      continue
+    }
+
+    if (!entry.name.endsWith('.ts') || entry.name.endsWith('.d.ts')) {
+      continue
+    }
+
+    const relativePath = fullPath.slice(baseDir.length + 1).replaceAll('\\', '/')
+    files.push(relativePath)
+  }
+
+  return files
+}
+
+const sourceFiles = (await walk(srcDir))
+  .filter((file) => file !== 'index.ts')
+  .sort((a, b) => a.localeCompare(b))
+
+const exportLines = sourceFiles.map((file) => {
+  return `export * from './src/${file.replace(/\.ts$/, '')}'`
+})
+
+const content = exportLines.length > 0 ? `${exportLines.join('\n')}\n` : ''
+await writeFile(outputFile, content, 'utf8')

package/src/array-set.ts

@@ -0,0 +1,28 @@
+export const useArraySet = () => {
+  // [1,2,3,4] [3,4,5,6] => [3,4]
+  const intersection = <T>(arr1: T[], arr2: T[]): T[] => {
+    return arr1.filter((item) => arr2.includes(item))
+  }
+
+  // [1,2,3,4] [3,4,5,6] => [1,2,3,4,5,6]
+  const union = <T>(arr1: T[], arr2: T[]): T[] => {
+    return [...new Set([...arr1, ...arr2])]
+  }
+
+  // [1,2,3,4] [3,4,5,6] => [1,2]
+  const complement = <T>(arr1: T[], arr2: T[]): T[] => {
+    return arr1.filter((item) => !arr2.includes(item))
+  }
+
+  // [1,2,3,4] [3,4,5,6] => [1,2,5,6]
+  const difference = <T>(arr1: T[], arr2: T[]): T[] => {
+    return [...complement(arr1, arr2), ...complement(arr2, arr1)]
+  }
+
+  return {
+    intersection,
+    union,
+    complement,
+    difference,
+  }
+}

package/src/create-singleton.ts

@@ -0,0 +1,43 @@
+export function createSingleton<T, Args extends any[]>(
+  createInstanceFn: (...args: Args) => T | Promise<T>,
+  options: {
+    isValid?: (instance: T, ...args: Args) => boolean
+  } = {},
+): ((...args: Args) => Promise<T>) & {reset: () => void; getInstance: () => T | null} {
+  let instance: T | null = null
+  let promise: Promise<T> | null = null
+
+  const get = async (...args: Args): Promise<T> => {
+    if (instance && (!options.isValid || options.isValid(instance, ...args))) {
+      return instance
+    }
+
+    if (promise) {
+      const result = await promise
+      if (!options.isValid || options.isValid(result, ...args)) {
+        return result
+      }
+    }
+
+    promise = (async () => {
+      try {
+        const newInstance = await createInstanceFn(...args)
+        instance = newInstance
+        return newInstance
+      } finally {
+        promise = null
+      }
+    })()
+
+    return promise
+  }
+
+  const reset = () => {
+    instance = null
+    promise = null
+  }
+
+  const getInstance = () => instance
+
+  return Object.assign(get, {reset, getInstance})
+}

package/src/datetime-formatter.ts

@@ -0,0 +1,12 @@
+export const formatDateTime = (datetime = Date.now()) => {
+  const UTC8DateTime = new Date(datetime + 1000 * 60 * 60 * 8)
+
+  const year = UTC8DateTime.getUTCFullYear()
+  const month = String(UTC8DateTime.getUTCMonth() + 1).padStart(2, '0')
+  const day = String(UTC8DateTime.getUTCDate()).padStart(2, '0')
+  const hour = String(UTC8DateTime.getUTCHours()).padStart(2, '0')
+  const minute = String(UTC8DateTime.getUTCMinutes()).padStart(2, '0')
+  const second = String(UTC8DateTime.getUTCSeconds()).padStart(2, '0')
+
+  return `${year}-${month}-${day} ${hour}:${minute}:${second}`
+}

package/src/route-matcher.ts

@@ -0,0 +1,64 @@
+interface MatchResult {
+  rule: string
+  type: 'allow' | 'block'
+  length: number
+}
+
+function isPathMatch(pathname: string, rule: string): boolean {
+  let normalizedRule = rule.startsWith('/') ? rule : `/${rule}`
+
+  if (normalizedRule.length > 1 && normalizedRule.endsWith('/')) {
+    normalizedRule = normalizedRule.slice(0, -1)
+  }
+
+  if (normalizedRule === '/') {
+    return true
+  }
+
+  if (pathname === normalizedRule || pathname === `${normalizedRule}/`) {
+    return true
+  }
+
+  if (pathname.startsWith(normalizedRule)) {
+    const nextChar = pathname[normalizedRule.length]
+    return nextChar === '/'
+  }
+
+  return false
+}
+
+export function isRouteAllowed(
+  pathname: string,
+  publicRoutes: string[],
+  privateRoutes: string[],
+): boolean {
+  const matches: MatchResult[] = []
+
+  publicRoutes.forEach((rule) => {
+    if (isPathMatch(pathname, rule)) {
+      matches.push({rule, type: 'allow', length: rule.length})
+    }
+  })
+
+  privateRoutes.forEach((rule) => {
+    if (isPathMatch(pathname, rule)) {
+      matches.push({rule, type: 'block', length: rule.length})
+    }
+  })
+
+  if (matches.length === 0) {
+    return false
+  }
+
+  matches.sort((a, b) => {
+    if (b.length !== a.length) {
+      return b.length - a.length
+    }
+    if (a.type === 'block' && b.type === 'allow') return -1
+    if (a.type === 'allow' && b.type === 'block') return 1
+    return 0
+  })
+
+  const bestMatch = matches[0]
+  return bestMatch?.type === 'allow'
+}

package/src/string-hash.ts

@@ -0,0 +1,6 @@
+export const hashSHA256 = async (key: string) => {
+  const msgBuffer = new TextEncoder().encode(key)
+  const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer)
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+}

package/src/timestamp-convert.ts

@@ -0,0 +1,80 @@
+export type TimePrecision = 'ms' | 's' | 'm' | 'h' | 'd'
+export type TimePrecisionISO = TimePrecision | 'iso' | (string & {})
+
+export function pt(timeStr: string): number
+export function pt(timeStr: string, precision: TimePrecision): number
+export function pt(timeStr: string, precision: `iso${string}`): string
+export function pt(timeStr: string, precision: TimePrecisionISO): number | string
+export function pt(timeStr: string, precision: TimePrecisionISO = 'ms'): number | string {
+  if (!timeStr) {
+    return 0
+  }
+
+  const match = timeStr.trim().match(/^(\d+(?:\.\d+)?)\s*([smhdwMy])(?:\s+(.+))?$/)
+
+  if (!match) {
+    return 0
+  }
+
+  const value = parseFloat(match[1]!)
+  const unit = match[2]
+  const suffix = match[3]?.toLowerCase()
+
+  const unitToMs: Record<string, number> = {
+    s: 1000,
+    m: 1000 * 60,
+    h: 1000 * 60 * 60,
+    d: 1000 * 60 * 60 * 24,
+    w: 1000 * 60 * 60 * 24 * 7,
+    M: 1000 * 60 * 60 * 24 * 31,
+    y: 1000 * 60 * 60 * 24 * 366,
+  }
+
+  const durationMs = value * (unitToMs[unit as keyof typeof unitToMs] ?? 0)
+
+  let resultMs = durationMs
+
+  if (suffix) {
+    const now = Date.now()
+    if (['ago', 'before'].includes(suffix)) {
+      resultMs = now - durationMs
+    } else if (['later', 'after'].includes(suffix)) {
+      resultMs = now + durationMs
+    }
+  }
+
+  if (precision.startsWith('iso')) {
+    if (precision === 'iso') {
+      return new Date(resultMs).toISOString()
+    }
+
+    const isoMatch = precision.match(/^iso([+-])(\d+(?:\.\d+)?)$/)
+    if (isoMatch) {
+      const sign = isoMatch[1] === '+' ? 1 : -1
+      const hours = parseFloat(isoMatch[2]!)
+      const offsetMs = sign * hours * 3600000
+      const localMs = resultMs + offsetMs
+
+      const absOffset = Math.abs(hours)
+      const h = Math.floor(absOffset)
+      const m = Math.floor((absOffset - h) * 60)
+      const tz = `${sign > 0 ? '+' : '-'}${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`
+
+      return new Date(localMs).toISOString().replace('Z', tz)
+    }
+  }
+
+  switch (precision) {
+    case 'd':
+      return Math.round(resultMs / 86400000)
+    case 'h':
+      return Math.round(resultMs / 3600000)
+    case 'm':
+      return Math.round(resultMs / 60000)
+    case 's':
+      return Math.round(resultMs / 1000)
+    case 'ms':
+    default:
+      return Math.round(resultMs)
+  }
+}