@adrienlcp/i18n 0.1.0 → 0.1.2

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/dist/translator.js

@@ -106,9 +106,10 @@ const FORMATTED_COUNT = '{?}';
  * That is dictionary text rather than a caller's value, so the rule above is
  * untouched.
  *
- * A value of the wrong type, or one the message never asked for, leaves its
- * placeholder standing rather than throwing: one bad value costs one word, not
- * the whole sentence.
+ * A value of the wrong type, one the message never asked for, or one the
+ * locale cannot print — an invalid `Date`, an infinite count, a code that names
+ * no language — leaves its placeholder standing rather than throwing: one bad
+ * value costs one word, not the whole sentence.
  */
 const substitute = ({ expanding = [], formatters, message, options, values }) => message.replace(PLACEHOLDER, (placeholder, name, type) => {
     const value = values[name];
@@ -117,7 +118,7 @@ const substitute = ({ expanding = [], formatters, message, options, values }) =>
     }
     switch (type) {
         case 'date':
-            return value instanceof Date
+            return isValidDate(value)
                 ? formatters.date(options.date?.[name]).format(value)
                 : placeholder;
         case 'displayname':
@@ -167,7 +168,7 @@ const substitute = ({ expanding = [], formatters, message, options, values }) =>
                 })
                 : placeholder;
         case 'relative':
-            return typeof value === 'number'
+            return typeof value === 'number' && Number.isFinite(value)
                 ? (relativeTime({
                     count: value,
                     formatters,
@@ -220,9 +221,21 @@ const pluralize = ({ count, formatters, forms }) => {
 /**
  * A message declaring `{x:displayname}` must declare the kind of name it wants,
  * so the options are never absent — but the runtime shape stays loose, and
- * `Intl.DisplayNames` throws without a `type`. Nothing rather than a crash.
+ * `Intl.DisplayNames` throws without a `type`, and on a string that is no code
+ * at all (`'not a language'`). Nothing rather than a crash.
  */
-const displayName = ({ formatters, of, options }) => options === undefined ? undefined : formatters.displayname(options).of(of);
+const displayName = ({ formatters, of, options }) => {
+    if (options === undefined) {
+        return undefined;
+    }
+    try {
+        return formatters.displayname(options).of(of);
+    }
+    catch {
+        return undefined;
+    }
+};
+const isValidDate = (value) => value instanceof Date && !Number.isNaN(value.getTime());
 /** Same reasoning: the unit is declared with the message, or there is none. */
 const relativeTime = ({ count, formatters, unit }) => unit === undefined
     ? undefined

package/package.json

@@ -24,13 +24,12 @@
     "type": "git",
     "url": "git+https://github.com/AdrienLcp/packages.git"
   },
+  "sideEffects": false,
+  "type": "module",
+  "version": "0.1.2",
   "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"
-}
+  }
+}