svelte-component-i18n 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# Svelte library
+
+Everything you need to build a Svelte library, powered by [`sv`](https://npmjs.com/package/sv).
+
+Read more about creating a library [in the docs](https://svelte.dev/docs/kit/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```sh
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```sh
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```sh
+npm pack
+```
+
+To create a production version of your showcase app:
+
+```sh
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```sh
+npm publish
+```

package/dist/dictionary.d.ts

@@ -0,0 +1,31 @@
+import type { Locale } from './locale.ts';
+type Localized<Languages extends string, Fallback extends Languages, T> = {
+    [K in Languages]?: T;
+} & {
+    [K in Fallback]-?: T;
+};
+type Quantifier = Intl.LDMLPluralRule;
+type Pluralized<T> = {
+    [K in Quantifier]?: T;
+} & {
+    [K in 'one']-?: T;
+};
+type FunctionLike = (...args: any[]) => unknown;
+type MaybeParameterized<T, V> = {
+    [K in keyof T as T[K] extends FunctionLike ? K : never]: (...args: MaybeParameters<T, K>) => V;
+} & {
+    [K in keyof T as T[K] extends FunctionLike ? never : K]: V;
+};
+type MaybeParameters<T, K extends keyof T> = T[K] extends FunctionLike ? Parameters<T[K]> : [];
+export type Texts<Languages extends string, Fallback extends Languages, T> = T & MaybeParameterized<T, Localized<Languages, Fallback, Pluralized<string> | string>>;
+export declare class Dictionary<Languages extends string, Fallback extends Languages, T> {
+    #private;
+    private readonly locale;
+    private readonly texts;
+    constructor(locale: () => Locale<Languages, Fallback>, texts: Texts<Languages, Fallback, T>);
+    readonly translate: <K extends keyof T>(key: K, ...params: MaybeParameters<T, K>) => string;
+    readonly t: <K extends keyof T>(key: K, ...params: MaybeParameters<T, K>) => string;
+    readonly pluralize: <K extends keyof T>(key: K, n: number, ...params: MaybeParameters<T, K>) => string;
+    readonly p: <K extends keyof T>(key: K, n: number, ...params: MaybeParameters<T, K>) => string;
+}
+export {};

package/dist/dictionary.js

@@ -0,0 +1,32 @@
+export class Dictionary {
+    locale;
+    texts;
+    constructor(locale, texts) {
+        this.locale = locale;
+        this.texts = texts;
+    }
+    #translate(key, ...params) {
+        return this.pluralize(key, 1, ...params);
+    }
+    #pluralize(key, n, ...params) {
+        const { language, fallback, pluralRules } = this.locale();
+        const maybeParameterized = this.texts[key];
+        const localized = typeof maybeParameterized === 'function' ? maybeParameterized(...params) : maybeParameterized;
+        const maybePluralized = has(localized, language) ? localized[language] : localized[fallback];
+        if (isPluralized(maybePluralized)) {
+            const quantifier = pluralRules.select(n);
+            return has(maybePluralized, quantifier) ? maybePluralized[quantifier] : maybePluralized.one;
+        }
+        return maybePluralized;
+    }
+    translate = this.#translate.bind(this);
+    t = this.translate;
+    pluralize = this.#pluralize.bind(this);
+    p = this.pluralize;
+}
+function has(value, key) {
+    return value[key] !== undefined && value[key] !== null;
+}
+function isPluralized(maybePluralized) {
+    return typeof maybePluralized === 'object' && 'one' in maybePluralized;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Translator } from './translator.svelte.ts';
+export { type Dictionary, type Texts } from './dictionary.ts';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Translator } from "./translator.svelte.js";
+export {} from "./dictionary.js";

package/dist/locale.d.ts

@@ -0,0 +1,5 @@
+export interface Locale<Languages extends string, Fallback extends Languages> {
+    language: Languages;
+    fallback: Fallback;
+    pluralRules: Intl.PluralRules;
+}

package/dist/locale.js

@@ -0,0 +1 @@
+export {};

package/dist/translator.svelte.d.ts

@@ -0,0 +1,9 @@
+import { Dictionary, type Texts } from './dictionary.ts';
+export declare class Translator<Languages extends string, Fallback extends Languages> {
+    readonly languages: Languages[];
+    readonly fallback: Fallback;
+    currentLanguage: Languages;
+    private readonly locale;
+    constructor(languages: Languages[], fallback: Fallback);
+    define<T>(texts: Texts<Languages, Fallback, T>): Dictionary<Languages, Fallback, T>;
+}

package/dist/translator.svelte.js

@@ -0,0 +1,28 @@
+import { Dictionary } from "./dictionary.js";
+export class Translator {
+    languages;
+    fallback;
+    currentLanguage;
+    locale;
+    constructor(languages, fallback) {
+        this.languages = languages;
+        this.fallback = fallback;
+        checkSupportedLanguages(languages);
+        this.currentLanguage = $state(fallback);
+        this.locale = $derived({
+            language: this.currentLanguage,
+            fallback: this.fallback,
+            pluralRules: new Intl.PluralRules(this.currentLanguage),
+        });
+    }
+    define(texts) {
+        return new Dictionary(() => this.locale, texts);
+    }
+}
+function checkSupportedLanguages(languages) {
+    const supportedLanguages = Intl.PluralRules.supportedLocalesOf(languages);
+    const unsupportedLanguages = languages.filter((l) => !supportedLanguages.includes(l));
+    if (unsupportedLanguages.length > 0) {
+        throw new Error(`Unsupported languages: ${unsupportedLanguages}`);
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "svelte-component-i18n",
+  "version": "0.0.1",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && npm run prepack",
+    "preview": "vite preview",
+    "prepare": "svelte-kit sync || echo ''",
+    "prepack": "svelte-kit sync && svelte-package && publint",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "format": "prettier --write .",
+    "lint": "prettier --check . && eslint .",
+    "test:unit": "vitest",
+    "test": "npm run test:unit -- --run"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.4.0",
+    "@eslint/js": "^9.39.1",
+    "@sveltejs/adapter-auto": "^7.0.0",
+    "@sveltejs/kit": "^2.49.1",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@types/node": "^22",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-svelte": "^3.13.1",
+    "globals": "^16.5.0",
+    "prettier": "^3.7.4",
+    "prettier-plugin-svelte": "^3.4.0",
+    "publint": "^0.3.15",
+    "svelte": "^5.45.6",
+    "svelte-check": "^4.3.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.1",
+    "vite": "^7.2.6",
+    "vitest": "^4.0.15"
+  },
+  "keywords": [
+    "svelte"
+  ]
+}