libp2r2p 0.9.0 → 0.10.1

package/README.md

@@ -326,60 +326,6 @@ Low-level relay sockets, subscriptions, message parsing, and serialization are
 internal implementation details; use `RelayPool` or the `relayPool` singleton
 from `libp2r2p/relay`.
 
-## Internationalization
-
-The dependency-free `libp2r2p/i18n` subpath exposes locale detection and a
-small translator suitable for keeping each component's translations beside
-that component. Translation keys are literal strings, not dotted paths.
-
-```js
-import { getT } from 'libp2r2p/i18n'
-
-const t = getT({
-  'Allow {{size}}': {
-    en: 'Allow {{size}}',
-    'pt-BR': 'Permitir {{size}}'
-  },
-  'Delete {{count}} items': {
-    en: {
-      one: 'Delete {{count}} item',
-      other: 'Delete {{count}} items'
-    }
-  }
-})
-
-t('Allow {{size}}', { size: '10 MiB' })
-```
-
-`getCurrentDeviceLocale()` prefers the locale resolved by `Intl`, then browser
-language hints, and preserves the full canonical BCP 47 locale. `getT()`
-matches exact and compatible language variants, falls back to English and then
-to the key itself, interpolates `{{name}}` values, and uses `Intl.PluralRules`
-when a locale value supplies plural forms. Missing interpolation values remain
-visible in the returned string.
-
-Catalog validation is opt-in. `validateLocales()` can be used independently,
-or `getT()` can validate once when creating the translator:
-
-```js
-import { getT, validateLocales } from 'libp2r2p/i18n'
-
-const validation = {
-  requiredLocales: ['en', 'pt-BR'],
-  referenceLocale: 'en',
-  requireReferenceKey: true
-}
-
-validateLocales(locales, validation)
-const t = getT(locales, { validation })
-```
-
-Validation checks catalog structure, required locales, plural `other` forms,
-and placeholder parity across every translation. `requireReferenceKey` also
-requires the reference locale's string, or its plural `other` form, to equal
-the literal translation key. Without `validation`, sparse catalogs continue
-to use the normal locale fallback behavior.
-
 ## Binary encodings
 
 Base16, Base36, Base62, Base64/Base64URL, and Base93 helpers are available

package/idb/index.js

@@ -13,6 +13,7 @@ const READ_METHODS = new Set([
 function deferred () {
   let resolve
   let reject
+  // eslint-disable-next-line promise/param-names
   const promise = new Promise((nextResolve, nextReject) => {
     resolve = nextResolve
     reject = nextReject

package/idb-queue/index.js

@@ -34,6 +34,7 @@ The queue state record is absent while the queue is empty.
 function deferred () {
   let resolve
   let reject
+  // eslint-disable-next-line promise/param-names
   const promise = new Promise((nextResolve, nextReject) => {
     resolve = nextResolve
     reject = nextReject

package/index.js

@@ -12,7 +12,6 @@ export * as error from './error/index.js'
 export * as event from './event/index.js'
 export * as idb from './idb/index.js'
 export * as idbQueue from './idb-queue/index.js'
-export * as i18n from './i18n/index.js'
 export * as key from './key/index.js'
 export * as kind from './kind/index.js'
 export * as network from './network/index.js'

package/nip04/index.js

@@ -1,7 +1,5 @@
 import { cbc } from '@noble/ciphers/aes.js'
 import { randomBytes } from '@noble/ciphers/utils.js'
-
-import { base16ToBytes } from '../base16/index.js'
 import { base64ToBytes, bytesToBase64 } from '../base64/index.js'
 import { sharedXOnlySecret } from '../ecdh/index.js'
 import { ValidationError } from '../error/index.js'

package/nip46/services/client.js

@@ -198,8 +198,7 @@ export class Nip46Client {
   }
 
   #openResponseContext (pointer) {
-    let context
-    context = this.#transport.openContext({
+    const context = this.#transport.openContext({
       filter: {
         kinds: [NIP46_KIND],
         authors: [pointer.remoteSignerPubkey],

package/nip46/services/server-session.js

@@ -112,8 +112,7 @@ export class Nip46ServerSession {
   }
 
   #openContext (relays) {
-    let context
-    context = this.#transport.openContext({
+    const context = this.#transport.openContext({
       filter: {
         kinds: [NIP46_KIND],
         '#p': [this.#transport.pubkey],

package/nip98/index.js

@@ -27,6 +27,7 @@ export async function getToken ({
   payloadHash
 }) {
   if (typeof loginUrl !== 'string' || loginUrl.length === 0) throw new ValidationError('INVALID_LOGIN_URL')
+  // eslint-disable-next-line no-new
   try { new URL(loginUrl) } catch (cause) { throw new ValidationError('INVALID_LOGIN_URL', { cause }) }
   if (typeof httpMethod !== 'string' || httpMethod.trim().length === 0) throw new ValidationError('INVALID_HTTP_METHOD')
   if (typeof signEvent !== 'function') throw new ValidationError('SIGN_EVENT_SHOULD_BE_A_FUNCTION')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -24,7 +24,6 @@
     "event",
     "idb",
     "idb-queue",
-    "i18n",
     "index.js",
     "key",
     "kind",
@@ -65,7 +64,6 @@
     "./event": "./event/index.js",
     "./idb": "./idb/index.js",
     "./idb-queue": "./idb-queue/index.js",
-    "./i18n": "./i18n/index.js",
     "./key": "./key/index.js",
     "./kind": "./kind/index.js",
     "./network": "./network/index.js",
@@ -94,6 +92,9 @@
     "@scure/base": "2.0.0"
   },
   "devDependencies": {
-    "fake-indexeddb": "6.2.5"
+    "eslint": "^9.39.5",
+    "fake-indexeddb": "6.2.5",
+    "globals": "^17.8.0",
+    "neostandard": "^0.13.0"
   }
 }

package/private-channel/services/received-chunks.js

@@ -52,6 +52,7 @@ state, keyPath "key"
 function deferred () {
   let resolve
   let reject
+  // eslint-disable-next-line promise/param-names
   const promise = new Promise((nextResolve, nextReject) => {
     resolve = nextResolve
     reject = nextReject

package/private-messenger/services/channel-state.js

@@ -25,6 +25,7 @@ clearing state owned by another instance of the same principal identity.
 function deferred () {
   let resolve
   let reject
+  // eslint-disable-next-line promise/param-names
   const promise = new Promise((nextResolve, nextReject) => {
     resolve = nextResolve
     reject = nextReject

package/relay/helpers/publish.js

@@ -40,6 +40,7 @@ export function createPublishSettlements (promises, timeout, { onSettled } = {})
   let isFinished = false
   let resolve
 
+  // eslint-disable-next-line promise/param-names
   const promise = new Promise(nextResolve => { resolve = nextResolve })
   const finish = () => {
     if (isFinished) return

package/relay/services/relay-pool.js

@@ -175,7 +175,7 @@ export class RelayPool {
 
   // Disconnect from a relay
   async disconnect (url) {
-    const normalizedUrl = normalizeURL(url)
+    const normalizedUrl = normalizeRelayUrl(url)
     if (this.#relays.has(normalizedUrl)) {
       const relay = this.#relays.get(normalizedUrl)
       if (relay.ws?.readyState < 2) await relay.close()?.catch(console.log)
@@ -414,6 +414,7 @@ export class RelayPool {
         this.#getRelay(url).then(relay => {
           if (isResolved || !pending.has(url)) return
           let hasEvents = false
+          // eslint-disable-next-line prefer-const
           let sub
 
           // Actual EOSE and filter satisfaction share the same graceful close path.
@@ -658,14 +659,13 @@ export class RelayPool {
         // the historical gap is yielded before newer socket events.
         let liveBuffer = (gapSince !== null && gapSince > 0) ? [] : null
         let liveEose = false
-        let liveSub
 
         // Open the live sub first so the relay starts buffering incoming events
         // before we scan its database for the reconnect gap fill.
         // Forward until to the relay so it can enforce the boundary server-side.
         const liveFilter = { ...baseFilter, since: now, limit: 0 }
         if (filterUntil !== null) liveFilter.until = filterUntil
-        liveSub = relay.subscribe([liveFilter], {
+        const liveSub = relay.subscribe([liveFilter], {
           onevent: (event) => {
             // A limit:0 relay may still send retained events before EOSE. Do not
             // expose them from a strictly-live stream.

package/i18n/index.js

@@ -1,237 +0,0 @@
-import { ValidationError } from '../error/index.js'
-
-const DEFAULT_LOCALE = 'en'
-const INTERPOLATION_RE = /{{\s*([A-Za-z0-9_.-]+)\s*}}/g
-
-function assertLocales (locales) {
-  if (!locales || typeof locales !== 'object' || Array.isArray(locales)) {
-    throw new ValidationError('INVALID_LOCALES', { message: 'locales should be an object' })
-  }
-}
-
-function placeholderSignature (value) {
-  return [...String(value).matchAll(INTERPOLATION_RE)]
-    .map(match => match[1])
-    .sort()
-    .join(',')
-}
-
-function validateTranslationValue (key, locale, value, expectedPlaceholders) {
-  if (typeof value === 'string') {
-    if (placeholderSignature(value) !== expectedPlaceholders) {
-      throw new ValidationError('I18N_PLACEHOLDER_MISMATCH', { message: `placeholder mismatch for "${key}" (${locale})` })
-    }
-    return
-  }
-
-  if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.other !== 'string') {
-    throw new ValidationError('INVALID_TRANSLATION', { message: `translation for "${key}" (${locale}) should be a string or plural object with an other form` })
-  }
-
-  for (const form of Object.values(value)) {
-    if (typeof form !== 'string') {
-      throw new ValidationError('INVALID_PLURAL_TRANSLATION', { message: `plural forms for "${key}" (${locale}) should be strings` })
-    }
-    if (placeholderSignature(form) !== expectedPlaceholders) {
-      throw new ValidationError('I18N_PLACEHOLDER_MISMATCH', { message: `placeholder mismatch for "${key}" (${locale})` })
-    }
-  }
-}
-
-export function validateLocales (locales, options = {}) {
-  assertLocales(locales)
-  if (!options || typeof options !== 'object' || Array.isArray(options)) {
-    throw new ValidationError('INVALID_I18N_VALIDATION_OPTIONS', { message: 'validation options should be an object' })
-  }
-  const {
-    requiredLocales = [],
-    referenceLocale = DEFAULT_LOCALE,
-    requireReferenceKey = false
-  } = options
-  if (!Array.isArray(requiredLocales) || requiredLocales.some(locale => typeof locale !== 'string' || !locale)) {
-    throw new ValidationError('INVALID_REQUIRED_LOCALES', { message: 'requiredLocales should be an array of non-empty strings' })
-  }
-  if (typeof referenceLocale !== 'string' || !referenceLocale) {
-    throw new ValidationError('INVALID_REFERENCE_LOCALE', { message: 'referenceLocale should be a non-empty string' })
-  }
-
-  for (const [key, translations] of Object.entries(locales)) {
-    if (!translations || typeof translations !== 'object' || Array.isArray(translations)) {
-      throw new ValidationError('INVALID_TRANSLATIONS', { message: `translations for "${key}" should be an object` })
-    }
-
-    for (const locale of requiredLocales) {
-      if (!Object.prototype.hasOwnProperty.call(translations, locale)) {
-        throw new ValidationError('MISSING_TRANSLATION', { message: `missing translation for "${key}" (${locale})` })
-      }
-    }
-
-    const expectedPlaceholders = placeholderSignature(key)
-    for (const [locale, value] of Object.entries(translations)) {
-      validateTranslationValue(key, locale, value, expectedPlaceholders)
-    }
-
-    if (requireReferenceKey) {
-      if (!Object.prototype.hasOwnProperty.call(translations, referenceLocale)) {
-        throw new ValidationError('MISSING_REFERENCE_TRANSLATION', { message: `missing reference translation for "${key}" (${referenceLocale})` })
-      }
-      const reference = translations[referenceLocale]
-      const referenceValue = typeof reference === 'string' ? reference : reference.other
-      if (referenceValue !== key) {
-        throw new ValidationError('REFERENCE_TRANSLATION_MISMATCH', { message: `reference translation should match key "${key}" (${referenceLocale})` })
-      }
-    }
-  }
-
-  return locales
-}
-
-function canonicalizeLocale (locale) {
-  if (typeof locale !== 'string' || !locale.trim()) return null
-  const value = locale.trim().replace(/_/g, '-')
-  try {
-    return Intl.getCanonicalLocales(value)[0] ?? null
-  } catch {
-    return null
-  }
-}
-
-function getIntlLocale () {
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().locale
-  } catch {
-    return null
-  }
-}
-
-function getNavigator () {
-  try {
-    return globalThis.navigator
-  } catch {
-    return null
-  }
-}
-
-export function getCurrentDeviceLocale () {
-  const navigator = getNavigator()
-  const candidates = [
-    getIntlLocale(),
-    navigator?.language,
-    navigator?.languages?.[0],
-    DEFAULT_LOCALE
-  ]
-
-  for (const candidate of candidates) {
-    const locale = canonicalizeLocale(candidate)
-    if (locale) return locale
-  }
-  return DEFAULT_LOCALE
-}
-
-function localeLanguage (locale) {
-  try {
-    return new Intl.Locale(locale).language
-  } catch {
-    return locale.split('-')[0].toLowerCase()
-  }
-}
-
-function preferredChineseLocale (locale) {
-  if (localeLanguage(locale) !== 'zh') return null
-  try {
-    const { script, region } = new Intl.Locale(locale)
-    if (script === 'Hant' || ['TW', 'HK', 'MO'].includes(region)) return 'zh-TW'
-    return 'zh-CN'
-  } catch {
-    return /(?:^|-)(?:hant|tw|hk|mo)(?:-|$)/i.test(locale) ? 'zh-TW' : 'zh-CN'
-  }
-}
-
-function localeCandidates (translations, requestedLocale, fallbackLocale) {
-  const keys = Object.keys(translations)
-  const canonicalKeys = new Map()
-  for (const key of keys) {
-    const canonical = canonicalizeLocale(key)
-    if (canonical && !canonicalKeys.has(canonical.toLowerCase())) {
-      canonicalKeys.set(canonical.toLowerCase(), { key, canonical })
-    }
-  }
-
-  const result = []
-  const seen = new Set()
-  const add = locale => {
-    const canonical = canonicalizeLocale(locale)
-    const match = canonical && canonicalKeys.get(canonical.toLowerCase())
-    if (match && !seen.has(match.key)) {
-      seen.add(match.key)
-      result.push(match)
-    }
-  }
-  const addCompatible = locale => {
-    const canonical = canonicalizeLocale(locale)
-    if (!canonical) return
-    add(canonical)
-    add(preferredChineseLocale(canonical))
-    const language = localeLanguage(canonical)
-    const match = [...canonicalKeys.values()].find(candidate => localeLanguage(candidate.canonical) === language)
-    if (match) add(match.canonical)
-  }
-
-  addCompatible(requestedLocale)
-  addCompatible(fallbackLocale)
-  addCompatible(DEFAULT_LOCALE)
-  return result
-}
-
-function selectPlural (forms, locale, values) {
-  if (!forms || typeof forms !== 'object' || Array.isArray(forms)) return null
-  const count = Number(values?.count)
-  if (!Number.isFinite(count)) return null
-
-  let category = 'other'
-  try {
-    category = new Intl.PluralRules(locale).select(count)
-  } catch {}
-  const value = forms[category] ?? forms.other
-  return typeof value === 'string' ? value : null
-}
-
-function selectTemplate (translations, requestedLocale, fallbackLocale, values) {
-  if (!translations || typeof translations !== 'object' || Array.isArray(translations)) return null
-  for (const { key, canonical } of localeCandidates(translations, requestedLocale, fallbackLocale)) {
-    const value = translations[key]
-    if (typeof value === 'string') return value
-    const plural = selectPlural(value, canonical, values)
-    if (plural !== null) return plural
-  }
-  return null
-}
-
-function interpolate (template, values) {
-  const source = String(template)
-  if (!values || typeof values !== 'object') return source
-  return source.replace(INTERPOLATION_RE, (token, name) => (
-    Object.prototype.hasOwnProperty.call(values, name)
-      ? String(values[name])
-      : token
-  ))
-}
-
-export function getT (locales, {
-  locale = getCurrentDeviceLocale(),
-  fallbackLocale = DEFAULT_LOCALE,
-  validation
-} = {}) {
-  assertLocales(locales)
-  if (validation !== undefined) validateLocales(locales, validation)
-
-  const requestedLocale = canonicalizeLocale(locale) ?? DEFAULT_LOCALE
-  const canonicalFallback = canonicalizeLocale(fallbackLocale) ?? DEFAULT_LOCALE
-
-  return function t (key, values) {
-    if (typeof key !== 'string') throw new ValidationError('INVALID_TRANSLATION_KEY', { message: 'translation key should be a string' })
-    const translations = Object.prototype.hasOwnProperty.call(locales, key) ? locales[key] : null
-    const template = selectTemplate(translations, requestedLocale, canonicalFallback, values) ?? key
-    return interpolate(template, values)
-  }
-}