@fluenti/vue 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Fluenti Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,380 @@
+# @fluenti/vue
+
+**Compile-time i18n for Vue 3. Zero runtime parsing. Type-safe templates.**
+
+[![npm version](https://img.shields.io/npm/v/@fluenti/vue?color=4f46e5&label=npm)](https://www.npmjs.com/package/@fluenti/vue)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/@fluenti/vue?color=16a34a&label=size)](https://bundlephobia.com/package/@fluenti/vue)
+[![license](https://img.shields.io/npm/l/@fluenti/vue?color=64748b)](https://github.com/usefluenti/fluenti/blob/main/LICENSE)
+
+Your translations are compiled at build time into optimized functions — no ICU parser ships to the browser, no runtime overhead, just fast string lookups. Write natural language in your templates; Fluenti handles the rest.
+
+---
+
+## The Magic: Write Natural Language, Ship Optimized Code
+
+### The `v-t` directive (compiled away at build time)
+
+`v-t` is not a runtime directive. It is a **Vue compiler transform** that rewrites your templates during build. What you write and what ships to production are two different things:
+
+```vue
+<!-- What you write -->
+<template>
+  <h1 v-t>Welcome to our app!</h1>
+  <p v-t>Hello, {name}!</p>
+  <p v-t.plural="count">one apple | {count} apples</p>
+  <img v-t.alt alt="Hero banner" src="/hero.png" />
+</template>
+```
+
+```vue
+<!-- What ships to the browser (conceptual) -->
+<template>
+  <h1>{{ $t('a1b2c3') }}</h1>
+  <p>{{ $t('d4e5f6', { name }) }}</p>
+  <p>{{ $t('{count, plural, one {# apple} other {# apples}}', { count }) }}</p>
+  <img :alt="$t('f7g8h9')" src="/hero.png" />
+</template>
+```
+
+No parsing. No interpretation. Just a hash lookup into a pre-compiled catalog. This is what compile-time i18n means.
+
+### The `t` tagged template (in `<script setup>`)
+
+For programmatic translations outside of templates, use `msg` with `useI18n()`:
+
+```vue
+<script setup lang="ts">
+import { useI18n } from '@fluenti/vue'
+
+const { t } = useI18n()
+
+const greeting = t('Hello, {name}!', { name: 'World' })
+const formatted = t('You have {count} items', { count: 42 })
+</script>
+```
+
+---
+
+## Quick Start
+
+### 1. Install
+
+```bash
+pnpm add @fluenti/core @fluenti/vue @fluenti/vite-plugin
+```
+
+### 2. Configure Vite
+
+```ts
+// vite.config.ts
+import vue from '@vitejs/plugin-vue'
+import fluenti from '@fluenti/vite-plugin'
+
+export default {
+  plugins: [vue(), fluenti({ framework: 'vue' })],
+}
+```
+
+### 3. Create the plugin
+
+```ts
+// main.ts
+import { createApp } from 'vue'
+import { createFluentVue } from '@fluenti/vue'
+import App from './App.vue'
+import en from './locales/compiled/en'
+import ja from './locales/compiled/ja'
+
+const fluent = createFluentVue({
+  locale: 'en',
+  fallbackLocale: 'en',
+  messages: { en, ja },
+})
+
+const app = createApp(App)
+app.use(fluent)
+app.mount('#app')
+```
+
+### 4. Use in your SFC
+
+```vue
+<script setup>
+import { useI18n } from '@fluenti/vue'
+
+const { locale, setLocale } = useI18n()
+</script>
+
+<template>
+  <h1 v-t>Hello, world!</h1>
+  <p v-t>Welcome to our application.</p>
+
+  <button @click="setLocale('ja')">日本語</button>
+</template>
+```
+
+That's it. Four files, zero boilerplate.
+
+---
+
+## Components
+
+### `<Trans>` — Rich Text with HTML and Components
+
+Translate text that contains inline HTML elements or Vue components. Child elements are preserved through the translation round-trip:
+
+```vue
+<template>
+  <Trans>Read the <a href="/docs">documentation</a></Trans>
+  <Trans>Click <RouterLink to="/next">here</RouterLink> to continue.</Trans>
+</template>
+```
+
+| Prop  | Type     | Default  | Description     |
+|-------|----------|----------|-----------------|
+| `tag` | `string` | `'span'` | Wrapper element |
+
+### `<Plural>` — Plural Forms
+
+Full ICU plural support as a component. Use string props for simple cases, or named slots for rich text:
+
+```vue
+<template>
+  <!-- Simple: string props -->
+  <Plural :value="count" zero="No items" one="1 item" other="{count} items" />
+
+  <!-- Rich: named slots -->
+  <Plural :value="count">
+    <template #zero>No <strong>items</strong> left</template>
+    <template #one><em>1</em> item remaining</template>
+    <template #other><strong>{{ count }}</strong> items remaining</template>
+  </Plural>
+</template>
+```
+
+| Prop    | Type     | Default  | Description                          |
+|---------|----------|----------|--------------------------------------|
+| `value` | `number` | required | The count to pluralize on            |
+| `zero`  | `string` | --       | Text for zero items (ICU `=0`)       |
+| `one`   | `string` | --       | Singular form                        |
+| `two`   | `string` | --       | Dual form                            |
+| `few`   | `string` | --       | Few form (some languages)            |
+| `many`  | `string` | --       | Many form (some languages)           |
+| `other` | `string` | `''`     | Default/fallback form                |
+| `tag`   | `string` | `'span'` | Wrapper element                      |
+
+Slots: `#zero`, `#one`, `#two`, `#few`, `#many`, `#other` -- each receives `{ count }` as slot props.
+
+### `<Select>` — Gender / Option Selection
+
+ICU select patterns as a component:
+
+```vue
+<template>
+  <!-- String props -->
+  <Select :value="gender" male="He liked this" female="She liked this" other="They liked this" />
+
+  <!-- Options map (recommended for dynamic keys) -->
+  <Select :value="role" :options="{ admin: 'Administrator', editor: 'Editor' }" other="Viewer" />
+
+  <!-- Rich text via slots -->
+  <Select :value="gender">
+    <template #male><strong>He</strong> liked this</template>
+    <template #female><strong>She</strong> liked this</template>
+    <template #other><em>They</em> liked this</template>
+  </Select>
+</template>
+```
+
+| Prop      | Type                      | Default  | Description                        |
+|-----------|---------------------------|----------|------------------------------------|
+| `value`   | `string`                  | required | The value to match against         |
+| `options` | `Record<string, string>`  | --       | Named options map                  |
+| `other`   | `string`                  | `''`     | Fallback when no option matches    |
+| `tag`     | `string`                  | `'span'` | Wrapper element                    |
+
+Slots: Named slots matching option keys, each receives `{ value }` as slot props.
+
+---
+
+## `v-t` Directive Reference
+
+| Modifier       | Effect                            |
+|----------------|-----------------------------------|
+| _(none)_       | Translates text content           |
+| `.plural`      | Enables plural forms (pipe syntax)|
+| `.alt`         | Translates the `alt` attribute    |
+| `.placeholder` | Translates the `placeholder` attribute |
+| `.title`       | Translates the `title` attribute  |
+| `.{attr}`      | Translates any named attribute    |
+
+```vue
+<template>
+  <h1 v-t>Hello, world!</h1>
+  <p v-t.plural="count">one apple | {count} apples</p>
+  <img v-t.alt alt="Welcome banner" src="banner.png" />
+  <input v-t.placeholder placeholder="Search..." />
+</template>
+```
+
+---
+
+## `useI18n()` Composable
+
+The full API surface, available inside any component with the plugin installed:
+
+```vue
+<script setup>
+import { useI18n } from '@fluenti/vue'
+
+const { t, d, n, locale, setLocale } = useI18n()
+</script>
+
+<template>
+  <p>{{ t('Hello, {name}!', { name: 'World' }) }}</p>
+  <p>{{ d(new Date(), 'long') }}</p>
+  <p>{{ n(1234.5, 'currency') }}</p>
+  <button @click="setLocale('ja')">日本語</button>
+</template>
+```
+
+| Method          | Signature                                                      | Description                                              |
+|-----------------|----------------------------------------------------------------|----------------------------------------------------------|
+| `t`             | `(id: string \| MessageDescriptor, values?) => string`         | Translate a key with optional interpolation              |
+| `d`             | `(value: Date \| number, style?) => string`                    | Format a date using `dateFormats` presets or Intl        |
+| `n`             | `(value: number, style?) => string`                            | Format a number using `numberFormats` presets or Intl    |
+| `format`        | `(message: string, values?) => string`                         | Format an ICU message string directly (no catalog lookup)|
+| `te`            | `(key: string, locale?) => boolean`                            | Check if a translation key exists                        |
+| `tm`            | `(key: string, locale?) => CompiledMessage \| undefined`       | Get the raw compiled message without interpolation       |
+| `locale`        | `Ref<string>` (readonly)                                       | Reactive ref for the current locale                      |
+| `setLocale`     | `(locale: string) => Promise<void>`                            | Change locale (async when lazy locale loading is enabled) |
+| `loadMessages`  | `(locale: string, messages: Messages) => void`                 | Dynamically add messages for a locale at runtime         |
+| `getLocales`    | `() => string[]`                                               | Get all locales that have loaded messages                |
+| `preloadLocale` | `(locale: string) => void`                                     | Preload a locale chunk in the background                 |
+| `isLoading`     | `Ref<boolean>` (readonly)                                      | Whether a locale chunk is currently being loaded         |
+| `loadedLocales` | `Ref<ReadonlySet<string>>` (readonly)                          | Set of locales whose messages have been loaded           |
+
+---
+
+## Plugin Options
+
+```ts
+const fluent = createFluentVue({
+  // Required
+  locale: 'en',
+  messages: { en, ja, zh },
+
+  // Optional
+  fallbackLocale: 'en',
+  fallbackChain: { 'zh-TW': ['zh', 'en'], '*': ['en'] },
+  dateFormats: {
+    short: { year: 'numeric', month: 'short', day: 'numeric' },
+    long:  { year: 'numeric', month: 'long', day: 'numeric', weekday: 'long' },
+    relative: 'relative',
+  },
+  numberFormats: {
+    currency: { style: 'currency', currency: 'USD' },
+    percent:  { style: 'percent', minimumFractionDigits: 1 },
+  },
+  missing: (locale, id) => `[missing: ${id}]`,
+  componentPrefix: 'I18n',   // registers I18nTrans, I18nPlural, I18nSelect
+  lazyLocaleLoading: true,
+  chunkLoader: (locale) => import(`./locales/${locale}.js`),
+
+  // Post-translation transform applied to every resolved message
+  transform: (result, id, locale) => result,
+
+  // Callback fired whenever the locale changes
+  onLocaleChange: (newLocale, prevLocale) => {
+    document.documentElement.lang = newLocale
+  },
+
+  // Custom ICU function formatters (e.g. {items, list})
+  formatters: {
+    list: (value, style, locale) =>
+      new Intl.ListFormat(locale, { type: style || 'conjunction' }).format(value),
+  },
+})
+```
+
+| Option            | Type                               | Default | Description                                              |
+|-------------------|------------------------------------|---------|----------------------------------------------------------|
+| `locale`          | `string`                           | --      | Active locale code (required)                            |
+| `messages`        | `Record<string, Messages>`         | --      | Pre-loaded message catalogs (required)                   |
+| `fallbackLocale`  | `string`                           | --      | Locale to try when a key is missing                      |
+| `fallbackChain`   | `Record<string, string[]>`         | --      | Locale-specific fallback chains (`'*'` for default)      |
+| `dateFormats`     | `Record<string, DateTimeFormatOptions \| 'relative'>` | -- | Named date format presets for `d()`             |
+| `numberFormats`   | `Record<string, NumberFormatOptions>` | --   | Named number format presets for `n()`                    |
+| `missing`         | `(locale, id) => string \| undefined` | --  | Handler called when a translation key is not found       |
+| `componentPrefix` | `string`                           | `''`    | Prefix for globally registered components                |
+| `lazyLocaleLoading` | `boolean`                        | `false` | Enable async locale loading through `chunkLoader`        |
+| `chunkLoader`     | `(locale) => Promise<Messages>`    | --      | Async loader for locale chunks (requires `lazyLocaleLoading`) |
+| `transform`       | `(result: string, id: string, locale: string) => string` | -- | Post-interpolation hook applied to every resolved message |
+| `onLocaleChange`  | `(newLocale: string, prevLocale: string) => void` | -- | Callback fired whenever the locale changes via `setLocale()` |
+| `formatters`      | `Record<string, CustomFormatter>`  | --      | Custom ICU function formatters keyed by function name    |
+
+---
+
+## Code Splitting
+
+For large apps, load locale messages on demand instead of bundling everything upfront:
+
+```ts
+const fluent = createFluentVue({
+  locale: 'en',
+  messages: { en },           // only the default locale is bundled
+  lazyLocaleLoading: true,
+  chunkLoader: (locale) => import(`./locales/compiled/${locale}.js`),
+})
+
+// Later: switching locale triggers async loading
+await fluent.global.setLocale('ja')  // loads ja chunk, then switches
+```
+
+Preload locales in the background for instant switching:
+
+```vue
+<script setup>
+const { setLocale, isLoading, preloadLocale } = useI18n()
+</script>
+
+<template>
+  <button @mouseenter="preloadLocale('ja')" @click="setLocale('ja')" :disabled="isLoading">
+    {{ isLoading ? 'Loading...' : '日本語' }}
+  </button>
+</template>
+```
+
+---
+
+## SSR / SSG Support
+
+`createFluentVue()` creates entirely fresh state per call -- no module-level singletons. Call it once per SSR request to avoid locale leaking between users.
+
+For server-side i18n in Nuxt or custom Vue SSR setups, use the dedicated server utilities:
+
+```ts
+import { createServerI18n, detectLocale, getSSRLocaleScript } from '@fluenti/vue/server'
+
+const { setLocale, getI18n } = createServerI18n({
+  loadMessages: (locale) => import(`./locales/compiled/${locale}.js`),
+  fallbackLocale: 'en',
+})
+```
+
+SSR utilities included:
+- `createServerI18n()` -- per-request i18n with lazy message loading and caching
+- `detectLocale()` -- locale detection from cookies, headers, path, or query
+- `getSSRLocaleScript()` -- inline script tag for hydration
+- `getHydratedLocale()` -- read the hydrated locale on the client
+- `isRTL()` / `getDirection()` -- RTL/LTR detection
+
+---
+
+## Documentation
+
+Full documentation at [fluenti.dev](https://fluenti.dev).
+
+## License
+
+[MIT](https://github.com/usefluenti/fluenti/blob/main/LICENSE)

package/dist/compile-time-t.d.ts

@@ -0,0 +1,3 @@
+import { CompileTimeT } from '@fluenti/core';
+export declare const t: CompileTimeT;
+//# sourceMappingURL=compile-time-t.d.ts.map

package/dist/compile-time-t.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-time-t.d.ts","sourceRoot":"","sources":["../src/compile-time-t.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,eAAO,MAAM,CAAC,EAAE,YAME,CAAA"}

package/dist/components/DateTime.d.ts

@@ -0,0 +1,60 @@
+import { ExtractPropTypes, PropType } from 'vue';
+/**
+ * `<DateTime>` component for formatting dates according to locale.
+ *
+ * @example
+ * ```vue
+ * <DateTime :value="new Date()" />
+ * <DateTime :value="Date.now()" style="short" />
+ * <DateTime :value="event.date" style="long" tag="time" />
+ * ```
+ */
+declare const dateTimeProps: {
+    readonly value: {
+        readonly type: PropType<Date | number>;
+        readonly required: true;
+    };
+    readonly style: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+};
+export type DateTimeProps = Readonly<ExtractPropTypes<typeof dateTimeProps>>;
+export declare const DateTime: import('vue').DefineComponent<ExtractPropTypes<{
+    readonly value: {
+        readonly type: PropType<Date | number>;
+        readonly required: true;
+    };
+    readonly style: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ExtractPropTypes<{
+    readonly value: {
+        readonly type: PropType<Date | number>;
+        readonly required: true;
+    };
+    readonly style: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+}>> & Readonly<{}>, {
+    readonly style: string;
+    readonly tag: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};
+//# sourceMappingURL=DateTime.d.ts.map

package/dist/components/DateTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DateTime.d.ts","sourceRoot":"","sources":["../../src/components/DateTime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAGrD;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa;;uBACgB,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC;;;;;;;;;;;CAGhD,CAAA;AAEV,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,gBAAgB,CAAC,OAAO,aAAa,CAAC,CAAC,CAAA;AAE5E,eAAO,MAAM,QAAQ;;uBAPc,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC;;;;;;;;;;;;;;;uBAAvB,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC;;;;;;;;;;;;;;4EAcxD,CAAA"}

package/dist/components/NumberFormat.d.ts

@@ -0,0 +1,60 @@
+import { ExtractPropTypes } from 'vue';
+/**
+ * `<NumberFormat>` component for formatting numbers according to locale.
+ *
+ * @example
+ * ```vue
+ * <NumberFormat :value="1234.56" />
+ * <NumberFormat :value="0.75" style="percent" />
+ * <NumberFormat :value="99.99" style="currency" tag="strong" />
+ * ```
+ */
+declare const numberFormatProps: {
+    readonly value: {
+        readonly type: NumberConstructor;
+        readonly required: true;
+    };
+    readonly style: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+};
+export type NumberFormatProps = Readonly<ExtractPropTypes<typeof numberFormatProps>>;
+export declare const NumberFormat: import('vue').DefineComponent<ExtractPropTypes<{
+    readonly value: {
+        readonly type: NumberConstructor;
+        readonly required: true;
+    };
+    readonly style: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ExtractPropTypes<{
+    readonly value: {
+        readonly type: NumberConstructor;
+        readonly required: true;
+    };
+    readonly style: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+}>> & Readonly<{}>, {
+    readonly style: string;
+    readonly tag: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};
+//# sourceMappingURL=NumberFormat.d.ts.map

package/dist/components/NumberFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NumberFormat.d.ts","sourceRoot":"","sources":["../../src/components/NumberFormat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAG3C;;;;;;;;;GASG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;CAIb,CAAA;AAEV,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAA;AAEpF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAOvB,CAAA"}

package/dist/components/Plural.d.ts

@@ -0,0 +1,138 @@
+import { ExtractPropTypes } from 'vue';
+/**
+ * `<Plural>` component — shorthand for ICU plural patterns.
+ *
+ * Plural form props (`zero`, `one`, `two`, `few`, `many`, `other`) are treated
+ * as source-language messages. The component builds an ICU plural message,
+ * looks it up via `t()` in the catalog, and interpolates the translated result.
+ *
+ * When no catalog translation exists, the component falls back to interpolating
+ * the source-language ICU message directly via the `message` field of the
+ * MessageDescriptor.
+ *
+ * Rich text is supported via named slots:
+ * ```vue
+ * <Plural :value="count">
+ *   <template #zero>No <strong>items</strong></template>
+ *   <template #one><em>1</em> item</template>
+ *   <template #other><strong>{{ count }}</strong> items</template>
+ * </Plural>
+ * ```
+ *
+ * String props still work (backward compatible):
+ * ```vue
+ * <Plural :value="count" zero="No items" one="# item" other="# items" />
+ * ```
+ */
+declare const pluralProps: {
+    /** The numeric value to pluralise on */
+    readonly value: {
+        readonly type: NumberConstructor;
+        readonly required: true;
+    };
+    /** Override the auto-generated synthetic ICU message id */
+    readonly id: StringConstructor;
+    /** Message context used for identity and translator disambiguation */
+    readonly context: StringConstructor;
+    /** Translator-facing note preserved in extraction catalogs */
+    readonly comment: StringConstructor;
+    /** Text for zero items (maps to `=0`) */
+    readonly zero: StringConstructor;
+    /** Text for singular (maps to `one`) */
+    readonly one: StringConstructor;
+    /** Text for dual (maps to `two`) */
+    readonly two: StringConstructor;
+    /** Text for few (maps to `few`) */
+    readonly few: StringConstructor;
+    /** Text for many (maps to `many`) */
+    readonly many: StringConstructor;
+    /** Text for the default/other category */
+    readonly other: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    /** Offset from value before selecting form */
+    readonly offset: NumberConstructor;
+    /** Wrapper element tag name (default: `span`) */
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+};
+export type PluralProps = Readonly<ExtractPropTypes<typeof pluralProps>>;
+export declare const Plural: import('vue').DefineComponent<ExtractPropTypes<{
+    /** The numeric value to pluralise on */
+    readonly value: {
+        readonly type: NumberConstructor;
+        readonly required: true;
+    };
+    /** Override the auto-generated synthetic ICU message id */
+    readonly id: StringConstructor;
+    /** Message context used for identity and translator disambiguation */
+    readonly context: StringConstructor;
+    /** Translator-facing note preserved in extraction catalogs */
+    readonly comment: StringConstructor;
+    /** Text for zero items (maps to `=0`) */
+    readonly zero: StringConstructor;
+    /** Text for singular (maps to `one`) */
+    readonly one: StringConstructor;
+    /** Text for dual (maps to `two`) */
+    readonly two: StringConstructor;
+    /** Text for few (maps to `few`) */
+    readonly few: StringConstructor;
+    /** Text for many (maps to `many`) */
+    readonly many: StringConstructor;
+    /** Text for the default/other category */
+    readonly other: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    /** Offset from value before selecting form */
+    readonly offset: NumberConstructor;
+    /** Wrapper element tag name (default: `span`) */
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ExtractPropTypes<{
+    /** The numeric value to pluralise on */
+    readonly value: {
+        readonly type: NumberConstructor;
+        readonly required: true;
+    };
+    /** Override the auto-generated synthetic ICU message id */
+    readonly id: StringConstructor;
+    /** Message context used for identity and translator disambiguation */
+    readonly context: StringConstructor;
+    /** Translator-facing note preserved in extraction catalogs */
+    readonly comment: StringConstructor;
+    /** Text for zero items (maps to `=0`) */
+    readonly zero: StringConstructor;
+    /** Text for singular (maps to `one`) */
+    readonly one: StringConstructor;
+    /** Text for dual (maps to `two`) */
+    readonly two: StringConstructor;
+    /** Text for few (maps to `few`) */
+    readonly few: StringConstructor;
+    /** Text for many (maps to `many`) */
+    readonly many: StringConstructor;
+    /** Text for the default/other category */
+    readonly other: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    /** Offset from value before selecting form */
+    readonly offset: NumberConstructor;
+    /** Wrapper element tag name (default: `span`) */
+    readonly tag: {
+        readonly type: StringConstructor;
+        readonly default: "span";
+    };
+}>> & Readonly<{}>, {
+    readonly other: string;
+    readonly tag: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};
+//# sourceMappingURL=Plural.d.ts.map

package/dist/components/Plural.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Plural.d.ts","sourceRoot":"","sources":["../../src/components/Plural.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAA4B,MAAM,KAAK,CAAA;AAsCrE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,QAAA,MAAM,WAAW;IACf,wCAAwC;;;;;IAExC,2DAA2D;;IAE3D,sEAAsE;;IAEtE,8DAA8D;;IAE9D,yCAAyC;;IAEzC,wCAAwC;;IAExC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,qCAAqC;;IAErC,0CAA0C;;;;;IAE1C,8CAA8C;;IAE9C,iDAAiD;;;;;CAEzC,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,gBAAgB,CAAC,OAAO,WAAW,CAAC,CAAC,CAAA;AAExE,eAAO,MAAM,MAAM;IA5BjB,wCAAwC;;;;;IAExC,2DAA2D;;IAE3D,sEAAsE;;IAEtE,8DAA8D;;IAE9D,yCAAyC;;IAEzC,wCAAwC;;IAExC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,qCAAqC;;IAErC,0CAA0C;;;;;IAE1C,8CAA8C;;IAE9C,iDAAiD;;;;;;;;IAtBjD,wCAAwC;;;;;IAExC,2DAA2D;;IAE3D,sEAAsE;;IAEtE,8DAA8D;;IAE9D,yCAAyC;;IAEzC,wCAAwC;;IAExC,oCAAoC;;IAEpC,mCAAmC;;IAEnC,qCAAqC;;IAErC,0CAA0C;;;;;IAE1C,8CAA8C;;IAE9C,iDAAiD;;;;;;;;4EAuDjD,CAAA"}