@viniaraujo68/plinth 0.3.0 → 0.5.0

package/dist/components/json-view.js

@@ -0,0 +1,302 @@
+export const DEFAULT_JSON_VIEW_LABELS = {
+    region: "JSON viewer",
+    search: "Search",
+    searchField: "Search keys and values",
+    previousMatch: "Previous match",
+    nextMatch: "Next match",
+    closeSearch: "Close search",
+    matchCount: (current, total) => `${current} of ${total}`,
+    noMatches: "No matches",
+    expandAll: "Expand all",
+    collapseAll: "Collapse all",
+    copy: "Copy JSON",
+    copied: "Copied",
+    expand: "Expand",
+    collapse: "Collapse",
+    items: (count) => (count === 1 ? "1 item" : `${count} items`),
+    circular: "[Circular]",
+    empty: "Nothing to show",
+};
+export const JSON_VIEW_GUTTER_CH = 2;
+export const JSON_VIEW_INDENT_CH = 2;
+const SKIPPED = Symbol("skipped");
+const escapePointerSegment = (segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1");
+const unbox = (value) => {
+    if (value instanceof Number)
+        return Number(value);
+    if (value instanceof String)
+        return String(value);
+    if (value instanceof Boolean || value instanceof BigInt)
+        return value.valueOf();
+    return value;
+};
+const resolveForJson = (raw, key) => {
+    let value = raw;
+    if ((typeof value === "object" && value !== null) || typeof value === "bigint") {
+        const toJSON = value.toJSON;
+        if (typeof toJSON === "function")
+            value = toJSON.call(value, key);
+    }
+    value = unbox(value);
+    if (value === undefined || typeof value === "function" || typeof value === "symbol")
+        return SKIPPED;
+    return value;
+};
+const isContainer = (value) => typeof value === "object" && value !== null;
+const closingBracket = (open) => (open === "[" ? "]" : "}");
+const primitiveToken = (value) => {
+    if (value === null)
+        return { text: "null", type: "null" };
+    if (typeof value === "string")
+        return { text: JSON.stringify(value), type: "string" };
+    if (typeof value === "boolean")
+        return { text: String(value), type: "boolean" };
+    if (typeof value === "bigint")
+        return { text: value.toString(), type: "number" };
+    if (typeof value === "number")
+        return Number.isFinite(value)
+            ? { text: JSON.stringify(value), type: "number" }
+            : { text: "null", type: "null" };
+    return { text: "null", type: "null" };
+};
+export const flattenJson = (value, options = {}) => {
+    const circular = options.circular ?? DEFAULT_JSON_VIEW_LABELS.circular;
+    const lines = [];
+    const ancestors = new Set();
+    const childrenOf = (container) => {
+        if (Array.isArray(container)) {
+            const items = container;
+            return Array.from({ length: items.length }, (_, index) => {
+                const segment = String(index);
+                const resolved = resolveForJson(items[index], segment);
+                return { segment, raw: items[index], value: resolved === SKIPPED ? null : resolved };
+            });
+        }
+        const record = container;
+        return Object.keys(record)
+            .map((segment) => ({
+            segment,
+            raw: record[segment],
+            value: resolveForJson(record[segment], segment),
+        }))
+            .filter((child) => child.value !== SKIPPED);
+    };
+    const visit = (raw, node, pointer, name, depth, parent, comma) => {
+        const index = lines.length;
+        if (!isContainer(node)) {
+            const { text, type } = primitiveToken(node);
+            lines.push({
+                kind: "value",
+                pointer,
+                id: pointer,
+                depth,
+                parent,
+                end: index + 1,
+                name,
+                text,
+                type,
+                size: 0,
+                comma,
+                source: raw,
+            });
+            return;
+        }
+        if (ancestors.has(node)) {
+            lines.push({
+                kind: "value",
+                pointer,
+                id: pointer,
+                depth,
+                parent,
+                end: index + 1,
+                name,
+                text: circular,
+                type: "circular",
+                size: 0,
+                comma,
+                source: raw,
+            });
+            return;
+        }
+        const isArray = Array.isArray(node);
+        const bracket = isArray ? "[" : "{";
+        const children = childrenOf(node);
+        const open = {
+            kind: "open",
+            pointer,
+            id: pointer,
+            depth,
+            parent,
+            end: index + 1,
+            name,
+            text: bracket,
+            type: null,
+            size: children.length,
+            comma,
+            source: raw,
+        };
+        lines.push(open);
+        if (children.length === 0)
+            return;
+        ancestors.add(node);
+        children.forEach((child, position) => {
+            visit(child.raw, child.value, `${pointer}/${escapePointerSegment(child.segment)}`, isArray ? null : JSON.stringify(child.segment), depth + 1, index, position < children.length - 1);
+        });
+        ancestors.delete(node);
+        lines.push({
+            kind: "close",
+            pointer,
+            id: `~${pointer}`,
+            depth,
+            parent: index,
+            end: lines.length + 1,
+            name: null,
+            text: closingBracket(bracket),
+            type: null,
+            size: 0,
+            comma,
+            source: raw,
+        });
+        open.end = lines.length;
+    };
+    const root = resolveForJson(value, "");
+    if (root !== SKIPPED)
+        visit(value, root, "", null, 0, -1, false);
+    return lines;
+};
+export const isFoldable = (line) => line.kind === "open" && line.size > 0;
+export const isFolded = (line, collapsed) => isFoldable(line) && collapsed.has(line.pointer);
+export const visibleLines = (lines, collapsed) => {
+    const visible = [];
+    let index = 0;
+    while (index < lines.length) {
+        visible.push(index);
+        const line = lines[index];
+        index = isFolded(line, collapsed) ? line.end : index + 1;
+    }
+    return visible;
+};
+export const ancestorLines = (lines, index) => {
+    const chain = [];
+    for (let parent = lines[index].parent; parent !== -1; parent = lines[parent].parent)
+        chain.push(parent);
+    return chain;
+};
+const foldCase = (text) => {
+    const lower = text.toLowerCase();
+    if (lower.length === text.length)
+        return lower;
+    let folded = "";
+    for (const character of text) {
+        const candidate = character.toLowerCase();
+        folded += candidate.length === character.length ? candidate : character;
+    }
+    return folded;
+};
+const occurrences = (text, needle) => {
+    const haystack = foldCase(text);
+    const starts = [];
+    for (let start = haystack.indexOf(needle); start !== -1; start = haystack.indexOf(needle, start + needle.length))
+        starts.push(start);
+    return starts;
+};
+export const searchJson = (lines, query) => {
+    if (query === "")
+        return [];
+    const needle = foldCase(query);
+    const matches = [];
+    lines.forEach((line, index) => {
+        if (line.name !== null)
+            for (const start of occurrences(line.name, needle))
+                matches.push({ line: index, field: "name", start, length: query.length });
+        if (line.kind === "value")
+            for (const start of occurrences(line.text, needle))
+                matches.push({ line: index, field: "value", start, length: query.length });
+    });
+    return matches;
+};
+export const matchSegments = (text, query) => {
+    if (query === "")
+        return [{ text, start: 0, match: false }];
+    const segments = [];
+    let cursor = 0;
+    for (const start of occurrences(text, foldCase(query))) {
+        if (start > cursor)
+            segments.push({ text: text.slice(cursor, start), start: cursor, match: false });
+        segments.push({ text: text.slice(start, start + query.length), start, match: true });
+        cursor = start + query.length;
+    }
+    if (cursor < text.length || segments.length === 0)
+        segments.push({ text: text.slice(cursor), start: cursor, match: false });
+    return segments;
+};
+export const subtreeHasMatch = (matches, open, end) => {
+    let low = 0;
+    let high = matches.length;
+    while (low < high) {
+        const middle = (low + high) >> 1;
+        if (matches[middle].line <= open)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low < matches.length && matches[low].line < end;
+};
+const nameWidth = (line) => (line.name === null ? 0 : line.name.length + 2);
+const leadWidth = (line) => JSON_VIEW_GUTTER_CH + line.depth * JSON_VIEW_INDENT_CH + nameWidth(line);
+export const lineWidthCh = (line) => {
+    const comma = line.comma ? 1 : 0;
+    if (line.kind === "value" || line.kind === "close")
+        return leadWidth(line) + line.text.length + comma;
+    if (line.size === 0)
+        return leadWidth(line) + 2 + comma;
+    return leadWidth(line) + 3 + comma + 1 + String(line.size).length;
+};
+export const maxLineWidthCh = (lines) => {
+    let widest = 0;
+    for (const line of lines)
+        widest = Math.max(widest, lineWidthCh(line));
+    return widest;
+};
+export const matchColumnCh = (line, match) => JSON_VIEW_GUTTER_CH +
+    line.depth * JSON_VIEW_INDENT_CH +
+    (match.field === "name" ? match.start : nameWidth(line) + match.start);
+export const lineText = (line) => {
+    const lead = line.name === null ? "" : `${line.name}: `;
+    const comma = line.comma ? "," : "";
+    if (line.kind === "value")
+        return lead + line.text + comma;
+    if (line.kind === "close")
+        return line.text + comma;
+    if (line.size === 0)
+        return lead + line.text + closingBracket(line.text) + comma;
+    return lead + line.text;
+};
+const NOTHING_COLLAPSED = new Set();
+const comparePoints = (a, b) => a.line === b.line ? a.column - b.column : a.line - b.line;
+export const copyJson = (lines, collapsed, from, to) => {
+    if (lines.length === 0)
+        return "";
+    const clamp = (point) => ({
+        line: Math.min(Math.max(point.line, 0), lines.length - 1),
+        column: Math.max(point.column, 0),
+    });
+    let [start, end] = comparePoints(from, to) <= 0 ? [from, to] : [to, from];
+    start = clamp(start);
+    end = clamp(end);
+    const startLine = lines[start.line];
+    if (isFolded(startLine, collapsed))
+        start = { line: start.line, column: Math.min(start.column, lineText(startLine).length) };
+    const endLine = lines[end.line];
+    if (isFolded(endLine, collapsed) && end.column > lineText(endLine).length)
+        end = { line: endLine.end - 1, column: Number.POSITIVE_INFINITY };
+    if (start.line === end.line)
+        return lineText(lines[start.line]).slice(start.column, end.column);
+    const parts = [lineText(startLine).slice(start.column)];
+    for (let index = start.line + 1; index < end.line; index += 1)
+        parts.push(" ".repeat(lines[index].depth * 2) + lineText(lines[index]));
+    const last = lines[end.line];
+    parts.push(end.column === 0 ? "" : " ".repeat(last.depth * 2) + lineText(last).slice(0, end.column));
+    return parts.join("\n");
+};
+export const copyAllJson = (lines) => copyJson(lines, NOTHING_COLLAPSED, { line: 0, column: 0 }, { line: lines.length - 1, column: Number.POSITIVE_INFINITY });

package/dist/components/request-error.d.ts

@@ -0,0 +1,8 @@
+import type { RequestErrorKind } from "../http.js";
+export interface RequestErrorCopy {
+    title: string;
+    message: string;
+}
+export type RequestErrorLabels = Partial<Record<RequestErrorKind, Partial<RequestErrorCopy>>>;
+export declare const DEFAULT_REQUEST_ERROR_COPY: Record<RequestErrorKind, RequestErrorCopy>;
+export declare const REQUEST_ERROR_ICONS: Record<RequestErrorKind, string[]>;

package/dist/components/request-error.js

@@ -0,0 +1,55 @@
+export const DEFAULT_REQUEST_ERROR_COPY = {
+    offline: {
+        title: "Connection problem",
+        message: "The request never reached the server. Check your connection and try again.",
+    },
+    unauthorized: {
+        title: "Sign-in required",
+        message: "Your session may have expired. Sign in again to continue.",
+    },
+    forbidden: {
+        title: "Access denied",
+        message: "You do not have permission to see this.",
+    },
+    "not-found": {
+        title: "Not found",
+        message: "What you asked for does not exist, or has moved.",
+    },
+    server: {
+        title: "Server error",
+        message: "The server ran into a problem. Try again in a moment.",
+    },
+    unknown: {
+        title: "Something went wrong",
+        message: "The application ran into an unexpected problem.",
+    },
+};
+export const REQUEST_ERROR_ICONS = {
+    offline: [
+        "M12 20h.01",
+        "M8.5 16.4a5 5 0 0 1 7 0",
+        "M5 12.9a10 10 0 0 1 5.2-2.7",
+        "M16.9 11.3a10 10 0 0 1 2.2 1.6",
+        "M2 8.8a15 15 0 0 1 4.2-2.6",
+        "M10.7 5a15 15 0 0 1 11.3 3.8",
+        "m2 2 20 20",
+    ],
+    unauthorized: [
+        "M5 11h14a2 2 0 0 1 2 2v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2",
+        "M7 11V7a5 5 0 0 1 10 0v4",
+    ],
+    forbidden: ["M12 22a10 10 0 1 0 0-20 10 10 0 0 0 0 20", "m4.9 4.9 14.2 14.2"],
+    "not-found": ["M11 19a8 8 0 1 0 0-16 8 8 0 0 0 0 16", "m21 21-4.3-4.3", "M8.5 11h5"],
+    server: [
+        "M6 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-2",
+        "M6 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-2",
+        "M6 6h.01",
+        "M6 18h.01",
+        "m13 6-4 6h6l-4 6",
+    ],
+    unknown: [
+        "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3",
+        "M12 9v4",
+        "M12 17h.01",
+    ],
+};

package/dist/components/tabs.d.ts

@@ -0,0 +1,5 @@
+/** One tab of a `Tabs` row. `id` is the value the row reports. */
+export interface TabItem<Id extends string = string> {
+    id: Id;
+    label: string;
+}

package/dist/components/tabs.js

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

package/dist/http.d.ts

@@ -32,12 +32,15 @@ export interface HttpClientOptions {
     auth?: AuthTokenSource;
     parseError?: ErrorMessageParser;
 }
+export interface RequestOptions {
+    signal?: AbortSignal;
+}
 export interface HttpClient {
-    get: <T = unknown>(path: string) => Promise<T>;
-    post: <T = unknown>(path: string, body?: unknown) => Promise<T>;
-    put: <T = unknown>(path: string, body?: unknown) => Promise<T>;
-    patch: <T = unknown>(path: string, body?: unknown) => Promise<T>;
-    del: <T = unknown>(path: string) => Promise<T>;
+    get: <T = unknown>(path: string, options?: RequestOptions) => Promise<T>;
+    post: <T = unknown>(path: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    put: <T = unknown>(path: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    patch: <T = unknown>(path: string, body?: unknown, options?: RequestOptions) => Promise<T>;
+    del: <T = unknown>(path: string, options?: RequestOptions) => Promise<T>;
 }
 /**
  * Build a client bound to one API.
@@ -66,3 +69,5 @@ export declare const errorMessage: (error: unknown) => string;
  * caller special-case 403 or 404 without an `instanceof` dance.
  */
 export declare const errorStatus: (error: unknown) => number;
+export type RequestErrorKind = "offline" | "unauthorized" | "forbidden" | "not-found" | "server" | "unknown";
+export declare const classifyError: (error: unknown, online?: boolean | undefined) => RequestErrorKind;

package/dist/http.js

@@ -71,7 +71,7 @@ const extractCode = (body) => {
  * ```
  */
 export const createHttpClient = ({ baseUrl, credentials, auth, parseError, }) => {
-    const request = async (method, path, body) => {
+    const request = async (method, path, body, options = {}) => {
         const headers = {};
         // GET and DELETE carry no body, and a `Content-Type` on them makes some CORS setups
         // preflight a request that would otherwise be simple.
@@ -89,6 +89,7 @@ export const createHttpClient = ({ baseUrl, credentials, auth, parseError, }) =>
             headers,
             credentials,
             body: body === undefined ? undefined : JSON.stringify(body),
+            signal: options.signal,
         });
         // Read as text first: 204 and most DELETEs answer with nothing at all, and `response.json()`
         // throws on an empty body. A non-JSON body (an HTML error page from a proxy) is kept as the
@@ -118,11 +119,11 @@ export const createHttpClient = ({ baseUrl, credentials, auth, parseError, }) =>
     // A body always goes out, even when the caller passes none — a bodyless POST is a 422 against a
     // FastAPI endpoint that declares a model, and `{}` is the harmless stand-in both references use.
     return {
-        get: (path) => request("GET", path),
-        post: (path, body) => request("POST", path, body ?? {}),
-        put: (path, body) => request("PUT", path, body ?? {}),
-        patch: (path, body) => request("PATCH", path, body ?? {}),
-        del: (path) => request("DELETE", path),
+        get: (path, options) => request("GET", path, undefined, options),
+        post: (path, body, options) => request("POST", path, body ?? {}, options),
+        put: (path, body, options) => request("PUT", path, body ?? {}, options),
+        patch: (path, body, options) => request("PATCH", path, body ?? {}, options),
+        del: (path, options) => request("DELETE", path, undefined, options),
     };
 };
 /**
@@ -136,3 +137,30 @@ export const errorMessage = (error) => error instanceof Error ? error.message :
  * caller special-case 403 or 404 without an `instanceof` dance.
  */
 export const errorStatus = (error) => error instanceof ApiError ? error.status : 0;
+const NETWORK_FAILURE = /failed to fetch|networkerror|load failed|fetch failed|network request failed|network connection|internet connection/i;
+const statusOf = (error) => {
+    const status = asRecord(error)?.status;
+    return typeof status === "number" ? status : undefined;
+};
+const isNetworkFailure = (error, online) => {
+    const record = asRecord(error);
+    if (record?.name !== "TypeError")
+        return false;
+    if (online === false)
+        return true;
+    return typeof record.message === "string" && NETWORK_FAILURE.test(record.message);
+};
+export const classifyError = (error, online = typeof navigator === "undefined" ? undefined : navigator.onLine) => {
+    const status = statusOf(error);
+    if (status === 401)
+        return "unauthorized";
+    if (status === 403)
+        return "forbidden";
+    if (status === 404)
+        return "not-found";
+    if (status !== undefined && status >= 500 && status <= 599)
+        return "server";
+    if (status === undefined && isNetworkFailure(error, online))
+        return "offline";
+    return "unknown";
+};

package/dist/i18n/LocaleToggle.svelte

@@ -0,0 +1,45 @@
+<script lang="ts" generics="L extends string">
+  import type { ClassValue } from "svelte/elements";
+  import SegmentedControl from "../components/SegmentedControl.svelte";
+  import type { I18n } from "./i18n.svelte.js";
+
+  interface Props {
+    /** The app's `I18n`. The toggle reads its locale and switches it; there is nothing to bind. */
+    i18n: I18n<L>;
+    /** Accessible name of the group — "Language". A prop because the library ships no translations. */
+    label: string;
+    /**
+     * What each button says. Defaults to the locale's id upper-cased, `PT` / `EN`, which is what a
+     * reader looking for their language scans for — a name in the current language would hide it
+     * from exactly the reader who cannot read that language.
+     */
+    labels?: Partial<Record<L, string>>;
+    /** `sm` fits a top bar or a sidebar footer; `md` is the size of the other segmented controls. */
+    size?: "sm" | "md";
+    class?: ClassValue;
+  }
+
+  let { i18n, label, labels = {}, size = "sm", class: className }: Props = $props();
+
+  const options = $derived(
+    i18n.locales.map((locale) => ({ id: locale, label: labels[locale] ?? locale.toUpperCase() })),
+  );
+</script>
+
+<!--
+@component
+The language switch: one button per locale the app's `I18n` offers, the current one pressed. It is a
+`SegmentedControl` underneath, so it looks and behaves like every other few-way choice in the app.
+
+```svelte
+<LocaleToggle {i18n} label={i18n.t("nav.language")} />
+```
+-->
+<SegmentedControl
+  {options}
+  value={i18n.locale}
+  {label}
+  {size}
+  class={className}
+  onchange={(locale) => i18n.setLocale(locale)}
+/>

package/dist/i18n/LocaleToggle.svelte.d.ts

@@ -0,0 +1,48 @@
+import type { ClassValue } from "svelte/elements";
+import type { I18n } from "./i18n.svelte.js";
+declare function $$render<L extends string>(): {
+    props: {
+        /** The app's `I18n`. The toggle reads its locale and switches it; there is nothing to bind. */
+        i18n: I18n<L>;
+        /** Accessible name of the group — "Language". A prop because the library ships no translations. */
+        label: string;
+        /**
+         * What each button says. Defaults to the locale's id upper-cased, `PT` / `EN`, which is what a
+         * reader looking for their language scans for — a name in the current language would hide it
+         * from exactly the reader who cannot read that language.
+         */
+        labels?: Partial<Record<L, string>>;
+        /** `sm` fits a top bar or a sidebar footer; `md` is the size of the other segmented controls. */
+        size?: "sm" | "md";
+        class?: ClassValue;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<L extends string> {
+    props(): ReturnType<typeof $$render<L>>['props'];
+    events(): ReturnType<typeof $$render<L>>['events'];
+    slots(): ReturnType<typeof $$render<L>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <L extends string>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<L>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<L>['props']>, ReturnType<__sveltets_Render<L>['events']>, ReturnType<__sveltets_Render<L>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<L>['bindings']>;
+    } & ReturnType<__sveltets_Render<L>['exports']>;
+    <L extends string>(internal: unknown, props: ReturnType<__sveltets_Render<L>['props']> & {}): ReturnType<__sveltets_Render<L>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+/**
+ * The language switch: one button per locale the app's `I18n` offers, the current one pressed. It is a
+ * `SegmentedControl` underneath, so it looks and behaves like every other few-way choice in the app.
+ *
+ * ```svelte
+ * <LocaleToggle {i18n} label={i18n.t("nav.language")} />
+ * ```
+ */
+declare const LocaleToggle: $$IsomorphicComponent;
+type LocaleToggle<L extends string> = InstanceType<typeof LocaleToggle<L>>;
+export default LocaleToggle;

package/dist/i18n/i18n.svelte.d.ts

@@ -0,0 +1,56 @@
+import { type Dictionary, type TranslationParams } from "./translate.js";
+export interface I18nOptions<L extends string> {
+    /** Every locale's strings. The keys of this object are the locales the app offers. */
+    dictionaries: Readonly<Record<L, Dictionary>>;
+    /** The BCP 47 tag of each locale — what `Intl` and `<html lang>` are given. */
+    tags: Readonly<Record<L, string>>;
+    /**
+     * The app's primary locale. The server always renders it, a key missing from the current
+     * dictionary is looked up in it, and a reader whose browser asks for nothing on offer gets it
+     * unless {@link I18nOptions.unmatched} says otherwise.
+     */
+    fallback: L;
+    /**
+     * The locale for a browser whose languages match none on offer. Defaults to `fallback`; an app
+     * written for one country usually wants its international locale here instead, so a French
+     * reader lands on English rather than on Portuguese.
+     */
+    unmatched?: L;
+    /** Where the reader's pick is remembered across visits. `null` remembers nothing. */
+    storageKey?: string | null;
+}
+/**
+ * The locale an app is shown in, and the `t()` that reads from it.
+ *
+ * Build one per app, at module level, and import it wherever text is rendered: `locale` is
+ * `$state`, so every `t()` read in a template or a `$derived` re-renders when it changes.
+ *
+ * On the server the instance is shared by every request the process handles and there is no
+ * per-request place to keep a reader's language, so it renders the fallback locale and refuses to
+ * switch — a switch there would leak one visitor's language into the next one's page. The browser
+ * corrects the text during hydration, from the remembered pick or the browser's languages.
+ */
+export declare class I18n<L extends string> {
+    #private;
+    /** The current locale. Switch it with {@link I18n.setLocale}, which also remembers the pick. */
+    locale: L;
+    /** Every locale on offer, in the order the dictionaries were declared. */
+    readonly locales: readonly L[];
+    constructor({ dictionaries, tags, fallback, unmatched, storageKey }: I18nOptions<L>);
+    /** The BCP 47 tag of the current locale, for `Intl` formatters and `toLocaleDateString`. */
+    get tag(): string;
+    /**
+     * The text for `key` in the current locale, with `{name}` placeholders filled from `params` and
+     * a plural form picked by `params.count`. A key the current dictionary lacks is read from the
+     * fallback one; a key neither has renders as itself — loud on screen, harmless otherwise.
+     *
+     * An arrow property rather than a method, so `const { t } = i18n` keeps working.
+     */
+    t: (key: string, params?: TranslationParams) => string;
+    /** Whether any dictionary has `key` — for text that is optional rather than missing. */
+    has: (key: string) => boolean;
+    /** Switches to `locale` and remembers it. Ignored on the server and for a locale not on offer. */
+    setLocale: (locale: L) => void;
+}
+/** An {@link I18n} for `options` — the one place an app declares its locales. */
+export declare const createI18n: <L extends string>(options: I18nOptions<L>) => I18n<L>;