@i18n-micro/core 1.3.0 → 1.3.2

package/package.json

@@ -1,35 +1,83 @@
 {
   "name": "@i18n-micro/core",
-  "version": "1.3.0",
-  "description": "",
-  "repository": "s00d/nuxt-i18n-micro",
+  "version": "1.3.2",
+  "description": "Core utilities for translations, formatting, and locale routing in Nuxt I18n Micro.",
+  "keywords": [
+    "formatting",
+    "i18n",
+    "locale",
+    "nuxt",
+    "translations"
+  ],
+  "homepage": "https://github.com/s00d/nuxt-i18n-micro/tree/main/packages/core#readme",
+  "bugs": {
+    "url": "https://github.com/s00d/nuxt-i18n-micro/issues"
+  },
   "license": "MIT",
-  "type": "module",
   "author": {
     "name": "s00d",
     "email": "Virus191288@gmail.com",
     "url": "https://s00d.github.io/"
   },
-  "homepage": "https://github.com/s00d/nuxt-i18n-micro",
-  "bugs": {
-    "url": "https://github.com/s00d/nuxt-i18n-micro/issues"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/s00d/nuxt-i18n-micro.git",
+    "directory": "packages/core"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
   "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": "./dist/index.mjs"
+    },
+    "./helpers": {
+      "import": {
+        "types": "./dist/helpers.d.ts",
+        "default": "./dist/helpers.mjs"
+      },
+      "require": {
+        "types": "./dist/helpers.d.cts",
+        "default": "./dist/helpers.cjs"
+      },
+      "default": "./dist/helpers.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "keywords": [],
   "dependencies": {
-    "@i18n-micro/types": "1.2.0"
+    "@i18n-micro/types": "1.2.4"
   },
   "devDependencies": {
+    "publint": "^0.3.17",
     "vite": "^7.3.1",
-    "vite-plugin-dts": "^4.5.4"
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=18"
   },
   "scripts": {
     "build": "vite build",
-    "test": "jest"
+    "check:package": "publint",
+    "test": "jest",
+    "test:perf": "jest --config jest.perf.config.cjs",
+    "test:dist": "vitest run --config vitest.dist.config.ts"
   }
 }

package/fix.ts

@@ -1 +0,0 @@
-import '@types/jest'

package/jest.config.cjs

@@ -1,7 +0,0 @@
-module.exports = {
-  roots: ['<rootDir>/tests'],
-  testMatch: ['**/?(*.)+(spec|test).[tj]s?(x)'],
-  transform: {
-    '^.+\\.ts$': 'ts-jest',
-  },
-}

package/src/base.ts

@@ -1,194 +0,0 @@
-import type { CleanTranslation, Getter, MissingHandler, Params, PluralFunc, TranslationKey, Translations } from '@i18n-micro/types'
-import { FormatService } from './format-service'
-import { defaultPlural, interpolate } from './helpers'
-import { type TranslationStorage, useTranslationHelper } from './translation'
-
-export interface BaseI18nOptions {
-  storage?: TranslationStorage
-  plural?: PluralFunc
-  missingWarn?: boolean
-  missingHandler?: (locale: string, key: string, routeName: string) => void
-  getCustomMissingHandler?: () => MissingHandler | null
-}
-
-/**
- * Abstract base class for i18n adapters
- *
- * Contains all common translation logic (t, ts, tc, tn, td, tdr, has).
- * Adapters must implement abstract methods to provide current state (locale, fallbackLocale, route).
- */
-export abstract class BaseI18n {
-  // Public fields (made public to allow type export in Nuxt plugins)
-  public helper: ReturnType<typeof useTranslationHelper>
-  public formatter = new FormatService()
-  public pluralFunc: PluralFunc
-  public missingWarn: boolean
-  public missingHandler?: (locale: string, key: string, routeName: string) => void
-  public getCustomMissingHandler?: () => MissingHandler | null
-
-  constructor(options: BaseI18nOptions = {}) {
-    this.helper = useTranslationHelper(options.storage)
-    this.formatter = new FormatService()
-    this.pluralFunc = options.plural || defaultPlural
-    this.missingWarn = options.missingWarn ?? true
-    this.missingHandler = options.missingHandler
-    this.getCustomMissingHandler = options.getCustomMissingHandler
-  }
-
-  // --- Abstract methods (must be implemented by subclasses) ---
-
-  /**
-   * Get current locale
-   */
-  public abstract getLocale(): string
-
-  /**
-   * Get fallback locale
-   */
-  public abstract getFallbackLocale(): string
-
-  /**
-   * Get current route name
-   */
-  public abstract getRoute(): string
-
-  // --- Public methods (implemented in base class) ---
-
-  /**
-   * Get translation for a key
-   * Based on logic from src/runtime/plugins/01.plugin.ts
-   */
-  public t(key: TranslationKey, params?: Params, defaultValue?: string | null, routeName?: string): CleanTranslation {
-    if (!key) return ''
-
-    // Use abstract getters to get current state
-    const locale = this.getLocale()
-    const route = routeName || this.getRoute()
-
-    // 1. Try to find translation in current locale
-    let value = this.helper.getTranslation<string>(locale, route, key)
-
-    // 2. Fallback to fallbackLocale if not found and different
-    if (!value) {
-      const fallbackLocale = this.getFallbackLocale()
-      if (locale !== fallbackLocale) {
-        value = this.helper.getTranslation<string>(fallbackLocale, route, key)
-      }
-    }
-
-    // 3. Handle missing
-    if (!value) {
-      // Call custom handler if set (Nuxt runtime), otherwise use instance handler
-      const customHandler = this.getCustomMissingHandler?.()
-      if (customHandler) {
-        customHandler(locale, key, route)
-      } else if (this.missingHandler) {
-        this.missingHandler(locale, key as string, route)
-      } else if (this.missingWarn) {
-        const isDev = process.env.NODE_ENV !== 'production'
-        const isClient = typeof window !== 'undefined'
-        if (isDev && isClient) {
-          console.warn(`Not found '${key}' key in '${locale}' locale messages for route '${route}'.`)
-        }
-      }
-      value = defaultValue === undefined ? key : defaultValue || key
-    }
-
-    // 4. Interpolate
-    return typeof value === 'string' && params ? interpolate(value, params) : (value as CleanTranslation)
-  }
-
-  /**
-   * Get translation as string
-   */
-  public ts(key: TranslationKey, params?: Params, defaultValue?: string, routeName?: string): string {
-    const value = this.t(key, params, defaultValue, routeName)
-    return value?.toString() ?? defaultValue ?? key
-  }
-
-  /**
-   * Plural translation
-   */
-  public tc(key: TranslationKey, count: number | Params, defaultValue?: string): string {
-    const { count: countValue, ...params } = typeof count === 'number' ? { count } : count
-
-    if (countValue === undefined) {
-      return defaultValue ?? key
-    }
-
-    // Getter passed to plural function
-    const getter: Getter = (k: TranslationKey, p?: Params, dv?: string) => {
-      return this.t(k, p, dv)
-    }
-
-    const result = this.pluralFunc(key, Number.parseInt(countValue.toString(), 10), params, this.getLocale(), getter)
-
-    return result ?? defaultValue ?? key
-  }
-
-  /**
-   * Format number
-   */
-  public tn(value: number, options?: Intl.NumberFormatOptions): string {
-    return this.formatter.formatNumber(value, this.getLocale(), options)
-  }
-
-  /**
-   * Format date
-   */
-  public td(value: Date | number | string, options?: Intl.DateTimeFormatOptions): string {
-    return this.formatter.formatDate(value, this.getLocale(), options)
-  }
-
-  /**
-   * Format relative time
-   */
-  public tdr(value: Date | number | string, options?: Intl.RelativeTimeFormatOptions): string {
-    return this.formatter.formatRelativeTime(value, this.getLocale(), options)
-  }
-
-  /**
-   * Check if translation exists
-   * Based on logic from src/runtime/plugins/01.plugin.ts
-   */
-  public has(key: TranslationKey, routeName?: string): boolean {
-    const route = routeName || this.getRoute()
-    const locale = this.getLocale()
-
-    // Check only through getTranslation (as in plugin)
-    return !!this.helper.getTranslation(locale, route, key)
-  }
-
-  /**
-   * Clear cache
-   */
-  public clearCache(): void {
-    this.helper.clearCache()
-  }
-
-  // --- Public methods (for subclasses to use) ---
-
-  /**
-   * Core translation loading logic (without reactivity)
-   * Subclasses can override addTranslations/addRouteTranslations to add reactivity
-   */
-  public loadTranslationsCore(locale: string, translations: Translations, merge: boolean, routeName = 'index'): void {
-    if (merge) {
-      this.helper.mergeTranslation(locale, routeName, translations, true)
-    } else {
-      this.helper.setTranslations(locale, translations, routeName)
-    }
-  }
-
-  /**
-   * Core route translation loading logic (without reactivity)
-   * Subclasses can override addRouteTranslations to add reactivity
-   */
-  public loadRouteTranslationsCore(locale: string, routeName: string, translations: Translations, merge: boolean): void {
-    if (merge) {
-      this.helper.mergeTranslation(locale, routeName, translations, true)
-    } else {
-      this.helper.loadPageTranslations(locale, routeName, translations)
-    }
-  }
-}

package/src/format-service.ts

@@ -1,41 +0,0 @@
-export class FormatService {
-  formatNumber(value: number, locale: string, options?: Intl.NumberFormatOptions): string {
-    return new Intl.NumberFormat(locale, options).format(value)
-  }
-
-  formatDate(value: Date | number | string, locale: string, options?: Intl.DateTimeFormatOptions): string {
-    const date = new Date(value)
-    if (Number.isNaN(date.getTime())) {
-      return 'Invalid Date'
-    }
-    return new Intl.DateTimeFormat(locale, options).format(date)
-  }
-
-  formatRelativeTime(value: Date | number | string, locale: string, options?: Intl.RelativeTimeFormatOptions): string {
-    const date = new Date(value)
-    if (Number.isNaN(date.getTime())) {
-      // Return "0 seconds ago" for invalid dates
-      return new Intl.RelativeTimeFormat(locale, options).format(0, 'second')
-    }
-    const now = new Date()
-    const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000)
-
-    const units: { unit: Intl.RelativeTimeFormatUnit; seconds: number }[] = [
-      { unit: 'year', seconds: 31536000 },
-      { unit: 'month', seconds: 2592000 },
-      { unit: 'day', seconds: 86400 },
-      { unit: 'hour', seconds: 3600 },
-      { unit: 'minute', seconds: 60 },
-      { unit: 'second', seconds: 1 },
-    ]
-
-    for (const { unit, seconds } of units) {
-      const diff = Math.floor(diffInSeconds / seconds)
-      if (diff >= 1) {
-        return new Intl.RelativeTimeFormat(locale, options).format(-diff, unit)
-      }
-    }
-
-    return new Intl.RelativeTimeFormat(locale, options).format(0, 'second')
-  }
-}

package/src/helpers.ts

@@ -1,54 +0,0 @@
-import type { Getter, Params, PluralFunc, Strategies, TranslationKey } from '@i18n-micro/types'
-
-const RE_TOKEN = /\{(\w+)\}/g
-
-export function interpolate(template: string, params: Params): string {
-  if (!params) return template
-
-  return template.replace(RE_TOKEN, (_, key) => {
-    const value = params[key]
-    return value !== undefined ? String(value) : `{${key}}`
-  })
-}
-
-export function withPrefixStrategy(strategy: Strategies) {
-  return strategy === 'prefix' || strategy === 'prefix_and_default'
-}
-
-export function isNoPrefixStrategy(strategy: Strategies) {
-  return strategy === 'no_prefix'
-}
-
-export function isPrefixStrategy(strategy: Strategies) {
-  return strategy === 'prefix'
-}
-
-export function isPrefixExceptDefaultStrategy(strategy: Strategies) {
-  return strategy === 'prefix_except_default'
-}
-
-export function isPrefixAndDefaultStrategy(strategy: Strategies) {
-  return strategy === 'prefix_and_default'
-}
-
-/**
- * Default pluralization function
- * Splits translation by '|' and selects form based on count
- * @param key - Translation key
- * @param count - Count for pluralization
- * @param params - Parameters for translation
- * @param _locale - Current locale (unused in default implementation)
- * @param getTranslation - Function to get translation value
- * @returns Selected plural form or null if not found
- */
-export const defaultPlural: PluralFunc = (key: TranslationKey, count: number, params: Params, _locale: string, getTranslation: Getter) => {
-  const translation = getTranslation(key, params)
-  if (!translation) {
-    return null
-  }
-  const forms = translation.toString().split('|')
-  if (forms.length === 0) return null
-  const selectedForm = count < forms.length ? forms[count] : forms[forms.length - 1]
-  if (!selectedForm) return null
-  return selectedForm.trim().replace('{count}', count.toString())
-}

package/src/index.ts

@@ -1,27 +0,0 @@
-import { BaseI18n, type BaseI18nOptions } from './base'
-import { FormatService } from './format-service'
-import {
-  defaultPlural,
-  interpolate,
-  isNoPrefixStrategy,
-  isPrefixAndDefaultStrategy,
-  isPrefixExceptDefaultStrategy,
-  isPrefixStrategy,
-  withPrefixStrategy,
-} from './helpers'
-import { type TranslationStorage, useTranslationHelper } from './translation'
-
-export {
-  useTranslationHelper,
-  interpolate,
-  withPrefixStrategy,
-  isNoPrefixStrategy,
-  isPrefixStrategy,
-  isPrefixExceptDefaultStrategy,
-  isPrefixAndDefaultStrategy,
-  defaultPlural,
-  FormatService,
-  BaseI18n,
-  type TranslationStorage,
-  type BaseI18nOptions,
-}

package/src/translation.ts

@@ -1,95 +0,0 @@
-import type { Translations } from '@i18n-micro/types'
-
-/**
- * Bare Metal: Simple translation storage without Ref, useState, devalue.
- * Map key: `${locale}:${routeName}` (page-specific).
- */
-export interface TranslationStorage {
-  translations: Map<string, Translations>
-}
-
-function findValue<T = unknown>(data: Translations | null | undefined, key: string): T | null {
-  if (!data || typeof key !== 'string') return null
-
-  if (key in data) {
-    const value = data[key]
-    if (typeof value === 'object' && value !== null) {
-      return value as T
-    }
-    return value as T
-  }
-
-  const parts = key.split('.')
-  let value: unknown = data
-  for (const part of parts) {
-    if (value && typeof value === 'object' && part in (value as object)) {
-      value = (value as Translations)[part]
-    } else {
-      return null
-    }
-  }
-  return (value as T) ?? null
-}
-
-export function useTranslationHelper(storage?: TranslationStorage) {
-  const translations = storage?.translations ?? new Map<string, Translations>()
-
-  return {
-    hasCache(locale: string, page: string) {
-      const p = page || 'index'
-      return translations.has(`${locale}:${p}`)
-    },
-    getCache(locale: string, routeName: string) {
-      const rn = routeName || 'index'
-      return translations.get(`${locale}:${rn}`)
-    },
-    setCache(_locale: string, _routeName: string, _cache: Map<string, unknown>) {
-      // No-op for bare metal
-    },
-    hasTranslation(locale: string, key: string): boolean {
-      for (const [k, v] of translations) {
-        if (k.startsWith(`${locale}:`) && findValue(v, key) !== null) {
-          return true
-        }
-      }
-      return false
-    },
-    hasPageTranslation(locale: string, routeName: string): boolean {
-      const rn = routeName || 'index'
-      return translations.has(`${locale}:${rn}`)
-    },
-    getTranslation<T = unknown>(locale: string, routeName: string, key: string): T | null {
-      const rn = routeName || 'index'
-      return findValue<T>(translations.get(`${locale}:${rn}`), key)
-    },
-    loadTranslations(locale: string, data: Translations, routeName = 'index'): void {
-      const rn = routeName || 'index'
-      const key = `${locale}:${rn}`
-      const existing = translations.get(key) ?? {}
-      translations.set(key, { ...existing, ...data })
-    },
-    setTranslations(locale: string, data: Translations, routeName = 'index'): void {
-      const rn = routeName || 'index'
-      translations.set(`${locale}:${rn}`, data)
-    },
-    loadPageTranslations(locale: string, routeName: string, data: Translations): void {
-      const rn = routeName || 'index'
-      const key = `${locale}:${rn}`
-      const existing = translations.get(key)
-      if (!existing || Object.keys(existing).length === 0) {
-        translations.set(key, data)
-      } else {
-        translations.set(key, { ...existing, ...data })
-      }
-    },
-    mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force = false): void {
-      const rn = routeName || 'index'
-      const key = `${locale}:${rn}`
-      const existing = translations.get(key) ?? {}
-      translations.set(key, { ...existing, ...newTranslations })
-    },
-    clearCache(): void {
-      translations.clear()
-    },
-  }
-}