@adrienlcp/i18n 0.1.0 → 0.1.1

package/dist/create-i18n.d.ts

@@ -25,6 +25,18 @@ type Localized<Reference> = Dictionary & DictionaryFor<Reference>;
 type AnyLoader = () => Promise<{
     default: Dictionary;
 }>;
+/**
+ * Refuses a `defaultLocale` typed as more than one locale. `const
+ * DEFAULT_LOCALE: Locale = 'en'` holds `'en'` but is typed `'en' | 'fr'`, which
+ * would make the reference every locale's dictionary at once: a second locale's
+ * leaves are plain `string`s, so every key with a placeholder would come out as
+ * `never` at the call site, far from the cause. The property name is the error
+ * TypeScript prints here instead.
+ */
+type SingleLocale<DefaultLocale extends string> = IsUnion<DefaultLocale> extends false ? unknown : {
+    'defaultLocale must be typed as one locale, not a union: write `const DEFAULT_LOCALE = "en" satisfies Locale`': never;
+};
+type IsUnion<Member, Whole = Member> = Member extends unknown ? [Whole] extends [Member] ? false : true : never;
 /**
  * One locale's entry held to the reference, whichever way it arrives. A loader
  * is compared through the dictionary its module `export default`s, so a locale
@@ -110,7 +122,7 @@ export type I18n<Reference, Locale extends string, DefaultLocale extends Locale
  * `load` resolves on the spot.
  */
 export declare const createI18n: <const Entries extends Record<string, Dictionary | AnyLoader>, const DefaultLocale extends keyof Entries & string>({ defaultLocale, dictionaries }: {
-    defaultLocale: DefaultLocale;
+    defaultLocale: DefaultLocale & SingleLocale<DefaultLocale>;
     dictionaries: Entries & { [Locale in keyof Entries]: Matching<Entries[DefaultLocale], Entries[Locale]>; } & Record<DefaultLocale, Localized<Entries[DefaultLocale]>>;
 }) => I18n<Entries[DefaultLocale], keyof Entries & string, DefaultLocale>;
 export {};

package/dist/dictionary.d.ts

@@ -38,6 +38,11 @@ export declare const defineDictionary: <const T extends { [Segment in keyof T]:
  * TypeScript's excess property check does the other half of the work: a key the
  * reference does not have is rejected at the literal, at every depth.
  *
+ * Only for a dictionary handed to `createTranslator` directly. One registered
+ * with `createI18n` is written through `defineDictionary`, like the reference:
+ * the annotation widens each message to `string`, and the registry, which
+ * compares placeholders, then refuses every message that has one.
+ *
  * ```ts
  * export const FR_DICTIONARY: DictionaryFor<typeof EN_DICTIONARY> = { … }
  * ```

package/package.json

@@ -24,13 +24,12 @@
     "type": "git",
     "url": "git+https://github.com/AdrienLcp/packages.git"
   },
+  "sideEffects": false,
+  "type": "module",
+  "version": "0.1.1",
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "pnpm build",
     "test": "vitest run",
     "test:watch": "vitest --watch"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "version": "0.1.0"
-}
+  }
+}