@sveltebase/i18n 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import * as use_intl_core from 'use-intl/core';
+import { State, PersistentState } from '@svelte-essentials/state';
+import { z } from 'zod';
+
+type MessageValue = string | {
+    [key: string]: MessageValue;
+};
+type Messages = {
+    [key: string]: MessageValue;
+};
+type LanguageDefinition<TLocale extends string = string, TMessages extends Messages = Messages> = {
+    code: TLocale;
+    label: string;
+    messages: TMessages;
+};
+type FormatOptions = {
+    preset?: "default" | "custom" | "birthday" | "month" | "timestring" | "full";
+    withTime?: boolean;
+};
+declare function getLanguage<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages, locale: TLanguages[number]["code"], fallbackLocale?: TLanguages[number]["code"]): LanguageDefinition<string, Messages>;
+declare function createLocaleTranslator<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages, locale: TLanguages[number]["code"], fallbackLocale?: TLanguages[number]["code"]): use_intl_core._Translator<Messages, never>;
+declare function createLocaleFormatter<TLocale extends string>(locale: TLocale, timeZone?: string): {
+    dateTime: {
+        (value: Date | number, options?: use_intl_core.DateTimeFormatOptions): string;
+        (value: Date | number, format?: string, options?: use_intl_core.DateTimeFormatOptions): string;
+    };
+    number: {
+        (value: number | bigint, options?: use_intl_core.NumberFormatOptions): string;
+        (value: number | bigint, format?: string, options?: use_intl_core.NumberFormatOptions): string;
+    };
+    relativeTime: {
+        (date: number | Date, now?: use_intl_core.RelativeTimeFormatOptions["now"]): string;
+        (date: number | Date, options?: use_intl_core.RelativeTimeFormatOptions): string;
+    };
+    list: {
+        <Value extends string | ReactElement<unknown, any>>(value: Iterable<Value>, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<ReactElement>;
+        <Value extends string | ReactElement<unknown, any>>(value: Iterable<Value>, format?: string, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<ReactElement>;
+    };
+    dateTimeRange: {
+        (start: Date | number, end: Date | number, options?: use_intl_core.DateTimeFormatOptions): string;
+        (start: Date | number, end: Date | number, format?: string, options?: use_intl_core.DateTimeFormatOptions): string;
+    };
+};
+declare function createFormatForLocale<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages, locale: TLanguages[number]["code"], fallbackLocale?: TLanguages[number]["code"], timeZone?: string): (value?: Date | number | string, options?: FormatOptions) => string | undefined;
+
+type LocaleSchema<TLocale extends string> = z.ZodType<TLocale>;
+type LocaleState<TLocale extends string> = State<TLocale> | PersistentState<LocaleSchema<TLocale>>;
+interface CreateI18nOptions<TLanguages extends readonly LanguageDefinition[], TFormat> {
+    languages: TLanguages;
+    fallbackLocale: TLanguages[number]["code"];
+    signatureLocale?: TLanguages[number]["code"];
+    storageKey?: string;
+    timeZone?: string;
+    createFormat(args: {
+        locale: TLanguages[number]["code"];
+        fallbackLocale: TLanguages[number]["code"];
+        signatureLocale?: TLanguages[number]["code"];
+        languages: TLanguages;
+        timeZone?: string;
+    }): TFormat;
+}
+declare function defineLanguages<const TLanguages extends readonly LanguageDefinition[]>(languages: TLanguages): TLanguages;
+declare function createI18n<const TLanguages extends readonly LanguageDefinition[], TFormat>(options: CreateI18nOptions<TLanguages, TFormat>): {
+    languages: TLanguages;
+    fallbackLocale: TLanguages[number]["code"];
+    signatureLocale: TLanguages[number]["code"] | undefined;
+    localeState: LocaleState<TLanguages[number]["code"]>;
+    setLocale: (locale: TLanguages[number]["code"]) => void;
+    getTranslations: (locale?: TLanguages[number]["code"]) => use_intl_core._Translator<Messages, never>;
+    getFormat: (locale?: TLanguages[number]["code"]) => TFormat;
+    getLanguage: (locale?: TLanguages[number]["code"]) => LanguageDefinition<string, Messages>;
+};
+
+export { type FormatOptions, type LanguageDefinition, type MessageValue, type Messages, createFormatForLocale, createI18n, createLocaleFormatter, createLocaleTranslator, defineLanguages, getLanguage };

package/dist/index.js

@@ -0,0 +1,217 @@
+// src/create-i18n.ts
+import { PersistentState, State } from "@svelte-essentials/state";
+import { z } from "zod";
+
+// src/utils.ts
+import { createFormatter, createTranslator } from "use-intl/core";
+import { SvelteDate } from "svelte/reactivity";
+import {
+  differenceInMinutes,
+  format as formatTimeWithDateFns,
+  isThisWeek,
+  isThisYear,
+  isToday,
+  isYesterday
+} from "date-fns";
+var UZ_WEEKDAYS = [
+  "Yakshanba",
+  "Dushanba",
+  "Seshanba",
+  "Chorshanba",
+  "Payshanba",
+  "Juma",
+  "Shanba"
+];
+var UZ_MONTHS = [
+  "Yanvar",
+  "Fevral",
+  "Mart",
+  "Aprel",
+  "May",
+  "Iyun",
+  "Iyul",
+  "Avgust",
+  "Sentabr",
+  "Oktabr",
+  "Noyabr",
+  "Dekabr"
+];
+function getLocaleCodes(languages) {
+  return languages.map((language) => language.code);
+}
+function getLanguage(languages, locale, fallbackLocale) {
+  return languages.find((language) => language.code === locale) ?? (fallbackLocale ? languages.find((language) => language.code === fallbackLocale) : void 0) ?? languages[0];
+}
+function createLocaleTranslator(languages, locale, fallbackLocale) {
+  const language = getLanguage(languages, locale, fallbackLocale);
+  return createTranslator({
+    locale: language.code,
+    messages: language.messages
+  });
+}
+function createLocaleFormatter(locale, timeZone = "Asia/Tashkent") {
+  return createFormatter({
+    locale,
+    timeZone,
+    now: new SvelteDate()
+  });
+}
+function toDate(value) {
+  return value instanceof Date ? value : new SvelteDate(value);
+}
+function formatTime(value) {
+  return formatTimeWithDateFns(value, "HH:mm");
+}
+function formatUzDate(value, withYear, withTime = false, suffix = "") {
+  let text = withYear ? `${value.getFullYear()}-yil, ${value.getDate()}-${UZ_MONTHS[value.getMonth()].toLowerCase()}` : `${value.getDate()}-${UZ_MONTHS[value.getMonth()].toLowerCase()}`;
+  if (withTime) {
+    text += `, ${formatTime(value)}${suffix}`;
+  }
+  return text;
+}
+function formatUzMonth(value, withYear) {
+  return withYear ? `${value.getFullYear()}-yil, ${UZ_MONTHS[value.getMonth()]}` : UZ_MONTHS[value.getMonth()];
+}
+function createFormatForLocale(languages, locale, fallbackLocale, timeZone = "Asia/Tashkent") {
+  const formatter = createLocaleFormatter(locale, timeZone);
+  const t = createLocaleTranslator(languages, locale, fallbackLocale);
+  return (value, options) => {
+    if (!value) {
+      return void 0;
+    }
+    const preset = options?.preset ?? "default";
+    const withTime = options?.withTime ?? false;
+    if (typeof value === "string" && preset === "timestring") {
+      const [hours = "0", minutes = "0", seconds = "0"] = value.split(":");
+      const timeDate = new SvelteDate();
+      timeDate.setHours(Number(hours), Number(minutes), Number(seconds), 0);
+      return formatter.dateTime(timeDate, {
+        hour: "numeric",
+        minute: "numeric"
+      });
+    }
+    const date = toDate(value);
+    if (preset === "full") {
+      return locale === "uz" ? formatUzDate(date, true, withTime) : formatter.dateTime(date, {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        ...withTime ? { hour: "numeric", minute: "numeric" } : {}
+      });
+    }
+    if (preset === "custom") {
+      const now = new SvelteDate();
+      const diffMinutes = differenceInMinutes(now, date);
+      if (diffMinutes < 1) return t("just-now");
+      if (diffMinutes < 60) return t("minutes-ago", { minutes: diffMinutes });
+      if (isToday(date)) return t("today-at", { time: formatTime(date) });
+      if (isYesterday(date)) return t("yesterday-at", { time: formatTime(date) });
+      if (isThisWeek(date, { weekStartsOn: 1 })) {
+        return locale === "uz" ? `${UZ_WEEKDAYS[date.getDay()]}, ${formatTime(date)} da` : formatter.dateTime(date, {
+          weekday: "long",
+          hour: "numeric",
+          minute: "numeric"
+        });
+      }
+      if (isThisYear(date)) {
+        return locale === "uz" ? formatUzDate(date, false, withTime, " da") : formatter.dateTime(date, {
+          month: "long",
+          day: "numeric",
+          ...withTime ? { hour: "numeric", minute: "numeric" } : {}
+        });
+      }
+      return locale === "uz" ? formatUzDate(date, true, withTime, " da") : formatter.dateTime(date, {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        ...withTime ? { hour: "numeric", minute: "numeric" } : {}
+      });
+    }
+    if (preset === "month") {
+      if (isThisYear(date)) {
+        return locale === "uz" ? formatUzMonth(date, false) : formatter.dateTime(date, { month: "long" });
+      }
+      return locale === "uz" ? formatUzMonth(date, true) : formatter.dateTime(date, { month: "long", year: "numeric" });
+    }
+    if (preset === "birthday") {
+      return locale === "uz" ? `${date.getFullYear()}-yil, ${date.getDate()}-${UZ_MONTHS[date.getMonth()]}` : formatter.dateTime(date, {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    }
+    if (isThisYear(date)) {
+      return locale === "uz" ? formatUzDate(date, false, withTime, " da") : formatter.dateTime(date, {
+        month: "long",
+        day: "numeric",
+        ...withTime ? { hour: "numeric", minute: "numeric" } : {}
+      });
+    }
+    return locale === "uz" ? formatUzDate(date, true, withTime, " da") : formatter.dateTime(date, {
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+      ...withTime ? { hour: "numeric", minute: "numeric" } : {}
+    });
+  };
+}
+
+// src/create-i18n.ts
+function defineLanguages(languages) {
+  return languages;
+}
+function createI18n(options) {
+  const { languages, fallbackLocale, signatureLocale, storageKey, timeZone, createFormat } = options;
+  const localeCodes = getLocaleCodes(languages);
+  const localeSchema = z.string().transform((value, context) => {
+    const nextLocale = value || fallbackLocale;
+    if (localeCodes.includes(nextLocale)) {
+      return nextLocale;
+    }
+    context.addIssue({
+      code: "custom",
+      message: `Invalid locale "${String(value)}"`
+    });
+    return z.NEVER;
+  });
+  const localeState = storageKey ? new PersistentState(storageKey, localeSchema) : new State(fallbackLocale);
+  function getLocale(locale) {
+    return locale ?? localeState.current;
+  }
+  function setLocale(locale) {
+    localeState.current = localeSchema.parse(locale);
+  }
+  function getTranslations(locale) {
+    return createLocaleTranslator(languages, getLocale(locale), fallbackLocale);
+  }
+  function getFormat(locale) {
+    return createFormat({
+      locale: getLocale(locale),
+      fallbackLocale,
+      signatureLocale,
+      languages,
+      timeZone
+    });
+  }
+  function getCurrentLanguage(locale) {
+    return getLanguage(languages, getLocale(locale), fallbackLocale);
+  }
+  return {
+    languages,
+    fallbackLocale,
+    signatureLocale,
+    localeState,
+    setLocale,
+    getTranslations,
+    getFormat,
+    getLanguage: getCurrentLanguage
+  };
+}
+export {
+  createFormatForLocale,
+  createI18n,
+  createLocaleFormatter,
+  createLocaleTranslator,
+  defineLanguages,
+  getLanguage
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@sveltebase/i18n",
+  "version": "0.1.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@sveltebase/state": "0.1.0",
+    "date-fns": "^4.1.0",
+    "use-intl": "^4.4.0",
+    "zod": "^4.1.11"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "check": "tsc --project tsconfig.json --noEmit",
+    "lint": "bun run build && publint --strict --pack npm",
+    "clean": "rm -rf dist"
+  }
+}