@aceshooting/lyra-ui 2.1.0 → 2.2.0

package/dist/components/flag/flag-peer.js

@@ -0,0 +1,13 @@
+import { loadFlagUrl, setFlagUrlResolver } from './flag.js';
+const peerResolver = loadFlagUrl(() => import('@aceshooting/lyra-flags'));
+setFlagUrlResolver(peerResolver);
+/**
+ * Register the optional `@aceshooting/lyra-flags` resolver for country and
+ * language based flags. Import this entry explicitly when that feature is
+ * used; the core Lyra barrel stays free of the optional asset graph.
+ */
+export async function registerLyraFlagPeer() {
+    return peerResolver;
+}
+void registerLyraFlagPeer();
+//# sourceMappingURL=flag-peer.js.map

package/dist/components/flag/flag-peer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag-peer.js","sourceRoot":"","sources":["../../../src/components/flag/flag-peer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAwB,MAAM,WAAW,CAAC;AAElF,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,yBAAyB,CAAC,CAAC,CAAC;AAC1E,kBAAkB,CAAC,YAAY,CAAC,CAAC;AAEjC;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB;IACxC,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,KAAK,oBAAoB,EAAE,CAAC"}

package/dist/components/flag/flag.class.d.ts

@@ -0,0 +1,124 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import '../skeleton/skeleton.class.js';
+export type FlagVariant = 'compact' | 'standard' | 'detailed';
+export type FlagUrlResolver = (code: string, options?: {
+    variant?: FlagVariant;
+}) => Promise<string | undefined>;
+/**
+ * Resolves the optional peer dependency `@aceshooting/lyra-flags`'s `flagUrl`
+ * via the given importer. Uncached and
+ * dependency-injectable — unlike `loadFlagUrlResolver()` below — so the
+ * caught-error warning path is directly testable without needing to
+ * actually uninstall the package.
+ */
+export declare function loadFlagUrl(importFlags: () => Promise<{
+    flagUrl: FlagUrlResolver;
+}>): Promise<FlagUrlResolver | null>;
+/** Install an optional flag resolver supplied by a peer-registration entry. */
+export declare function setFlagUrlResolver(value: FlagUrlResolver | Promise<FlagUrlResolver | null> | null): void;
+/**
+ * `<lyra-flag>` — a country/language flag.
+ *
+ * Flag images are shipped by the optional peer package `@aceshooting/lyra-flags`,
+ * not bundled into lyra-ui itself, so importing the core library pulls zero flag
+ * weight. Give it a `country` (ISO 3166-1 alpha-2) or a `language` tag (mapped to
+ * a representative country). While that peer package's `flagUrl()` resolves (or
+ * if it isn't installed), the host carries `aria-busy="true"` and a skeleton
+ * placeholder renders in its place.
+ *
+ * **Bundle-size note:** `country`/`language` resolve through the peer package's
+ * `flagUrl(code)`, which lazily fetches one requested flag at runtime. A
+ * bundler may still emit the complete reachable lazy-chunk graph; use a
+ * literal asset subpath import when the deployment artifact must be pruned.
+ * If you already
+ * have a flag's URL at build time (e.g. from your own literal
+ * `import frUrl from '@aceshooting/lyra-flags/flags/fr.svg?url'`), pass it as
+ * `src` instead to skip the peer-package round trip (and its loading-skeleton
+ * flash) entirely.
+ *
+ * The ~65 flags whose design includes a detailed coat of arms/seal/emblem (e.g. `es`, `pt`) ship
+ * three fidelity tiers; choose one with `variant`: `"compact"` (a tiny WebP raster for icon-scale
+ * use — menu items, language selectors, dense lists), the default `"standard"` (icon-optimized
+ * vector for card/row sizes), or `"detailed"` (the pristine full-detail vector for hero-scale
+ * display). A no-op for every other code — all tiers resolve to the same file. See `variant`'s own
+ * doc.
+ *
+ * @customElement lyra-flag
+ * @example <lyra-flag country="fr"></lyra-flag>
+ * @example <lyra-flag language="en" label="English"></lyra-flag>
+ * @example <lyra-flag src=${frUrl} label="French"></lyra-flag>
+ * @example <lyra-flag country="es" variant="compact"></lyra-flag>
+ * @example <lyra-flag country="es" variant="detailed"></lyra-flag>
+ * @csspart image - The underlying <img>.
+ */
+export declare class LyraFlag extends LyraElement {
+    static styles: import("lit").CSSResultGroup[];
+    /** ISO 3166-1 alpha-2 country code (e.g. `fr`, `us`). Takes precedence over `language`. */
+    country?: string;
+    /** BCP-47-ish language tag (e.g. `en`, `en-US`) resolved to a country flag. */
+    language?: string;
+    /**
+     * A pre-resolved flag image URL — takes precedence over `country`/`language`
+     * and skips the `@aceshooting/lyra-flags` peer-package lookup (and its
+     * loading-skeleton round trip) entirely. See the class doc: mainly useful to
+     * avoid even the small per-flag async hop when you already have the URL at
+     * build time. `label` is effectively required alongside `src` — there's no
+     * `country`/`language` to derive a fallback `alt` from.
+     */
+    src?: string;
+    /**
+     * Accessible label / `alt` text. Defaults to a localized, human-readable
+     * region name derived from the *resolved country code* via
+     * `Intl.DisplayNames` (e.g. `"United Kingdom"`) — for a `language`-only
+     * element (e.g. `language="en"`) that's the mapped country's display name,
+     * not the language tag itself. Falls back to the bare uppercase code if
+     * `Intl.DisplayNames` can't resolve it. Has no default when only `src` is
+     * given (no country/language to derive one from).
+     */
+    label?: string;
+    /** Render as a circular flag. */
+    round: boolean;
+    /**
+     * Which fidelity tier to load, for the ~65 `country`/`language` codes whose source art embeds a
+     * coat of arms/seal/emblem (for every other code all tiers are the same file, so this is a safe
+     * no-op):
+     * - `"compact"` — a tiny WebP raster for icon-scale use (menu items, language selectors, dense
+     *   lists; ~12–28px), where the emblem detail is invisible anyway.
+     * - `"standard"` (default) — the icon-optimized vector, for card/row sizes (~28–96px).
+     * - `"detailed"` — the pristine, full-detail vector, for rendering larger than icon scale (e.g.
+     *   a hero display) where the extra illustrative detail is actually visible.
+     *
+     * Has no effect when `src` is set — a pre-resolved URL is used as-is regardless. Takes precedence
+     * over the deprecated `detailed` boolean.
+     */
+    variant?: FlagVariant;
+    /**
+     * @deprecated Use `variant="detailed"` instead. Kept as an alias for one minor cycle; when
+     * `variant` is unset, `detailed` still maps to the detailed tier. Removed in the next major.
+     */
+    detailed: boolean;
+    /** The effective tier to request: an explicit `variant` wins; otherwise the deprecated
+     *  `detailed` boolean is honored; otherwise `"standard"`. */
+    private get effectiveVariant();
+    private resolvedSrc?;
+    /** True while the lazy-loaded `@aceshooting/lyra-flags` peer resolver is in flight. */
+    private loading;
+    /**
+     * Bumped on every `willUpdate` pass; captured by each in-flight resolver
+     * `.then()` so a resolution for a `country`/`language` that's since changed
+     * (or been cleared) can recognize itself as stale and no-op instead of
+     * overwriting newer state.
+     */
+    private resolveToken;
+    private get code();
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-flag': LyraFlag;
+    }
+}
+//# sourceMappingURL=flag.class.d.ts.map

package/dist/components/flag/flag.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag.class.d.ts","sourceRoot":"","sources":["../../../src/components/flag/flag.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAG7D,OAAO,+BAA+B,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,WAAW,CAAA;CAAE,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAEjH;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,WAAW,EAAE,MAAM,OAAO,CAAC;IAAE,OAAO,EAAE,eAAe,CAAA;CAAE,CAAC,GACvD,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAUjC;AAoCD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAExG;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,QAAS,SAAQ,WAAW;IACvC,MAAM,CAAC,MAAM,iCAAgC;IAE7C,2FAA2F;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;IAE7B,+EAA+E;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;;;OAOG;IACS,GAAG,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;;OAQG;IACS,KAAK,CAAC,EAAE,MAAM,CAAC;IAE3B,iCAAiC;IACW,KAAK,UAAS;IAE1D;;;;;;;;;;;;OAYG;IACS,OAAO,CAAC,EAAE,WAAW,CAAC;IAElC;;;OAGG;IACyC,QAAQ,UAAS;IAE7D;iEAC6D;IAC7D,OAAO,KAAK,gBAAgB,GAE3B;IAEQ,OAAO,CAAC,WAAW,CAAC,CAAS;IAEtC,uFAAuF;IAC9E,OAAO,CAAC,OAAO,CAAQ;IAEhC;;;;;OAKG;IACH,OAAO,CAAC,YAAY,CAAK;IAEzB,OAAO,KAAK,IAAI,GAMf;IAED,UAAmB,UAAU,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI,CA4CjE;IAED,SAAS,CAAC,OAAO,IAAI,IAAI,CAGxB;IAED,MAAM,IAAI,cAAc,CAOvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,WAAW,EAAE,QAAQ,CAAC;KACvB;CACF"}

package/dist/components/flag/flag.class.js

@@ -0,0 +1,251 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { styles } from './flag.styles.js';
+import { ALPHA2_RE, languageToCountry } from './language-map.js';
+import '../skeleton/skeleton.class.js';
+/**
+ * Resolves the optional peer dependency `@aceshooting/lyra-flags`'s `flagUrl`
+ * via the given importer. Uncached and
+ * dependency-injectable — unlike `loadFlagUrlResolver()` below — so the
+ * caught-error warning path is directly testable without needing to
+ * actually uninstall the package.
+ */
+export async function loadFlagUrl(importFlags) {
+    try {
+        return (await importFlags()).flagUrl;
+    }
+    catch {
+        console.warn("<lyra-flag> needs the optional peer dependency '@aceshooting/lyra-flags' to render " +
+            'flag images — install it with `pnpm add @aceshooting/lyra-flags`.');
+        return null;
+    }
+}
+/**
+ * One `Intl.DisplayNames` instance per locale, shared across every `<lyra-flag>` on the page.
+ * Constructing one is an ICU locale-data lookup, and `displayNameFor()` runs on every `render()`
+ * pass for a flag without an explicit `label` (e.g. toggling `round`), not just on country/language
+ * change -- multi-flag lists (language pickers, country lists) would otherwise pay this cost once
+ * per element per render. Mirrors the module-level caching `flagUrlResolver` already gets above.
+ */
+const displayNamesCache = new Map();
+/**
+ * Resolves an ISO 3166-1 alpha-2 region code to a human-readable, localized
+ * display name (e.g. `'FR'` -> `'France'`) via `Intl.DisplayNames`, for use as
+ * the default accessible name (`alt`) instead of a bare code read
+ * letter-by-letter by most screen readers. Falls back to the uppercase code
+ * itself if `Intl.DisplayNames` throws (unrecognized region) or isn't
+ * available in the current runtime.
+ */
+function displayNameFor(code) {
+    try {
+        const locale = navigator.language;
+        let dn = displayNamesCache.get(locale);
+        if (!dn) {
+            dn = new Intl.DisplayNames([locale], { type: 'region' });
+            displayNamesCache.set(locale, dn);
+        }
+        return dn.of(code.toUpperCase()) ?? code.toUpperCase();
+    }
+    catch {
+        return code.toUpperCase();
+    }
+}
+let flagUrlResolver;
+let testFlagUrlResolver;
+/** Install an optional flag resolver supplied by a peer-registration entry. */
+export function setFlagUrlResolver(value) {
+    flagUrlResolver = value === null ? Promise.resolve(null) : Promise.resolve(value);
+}
+/**
+ * Lazily loads the optional peer dependency '@aceshooting/lyra-flags' once per
+ * page. Resolves to `null` (with a one-time warning, see `loadFlagUrl()`) if
+ * it isn't installed.
+ */
+function loadFlagUrlResolver() {
+    if (testFlagUrlResolver)
+        return testFlagUrlResolver;
+    if (!flagUrlResolver) {
+        // The core component intentionally has no optional-peer import in its
+        // module graph. Import `flag-peer.js` when country/language resolution is
+        // wanted; otherwise a flag with no pre-resolved `src` simply renders empty.
+        flagUrlResolver = Promise.resolve(null);
+    }
+    return flagUrlResolver;
+}
+/**
+ * @internal Test-only seam: overrides (or, with `undefined`, restores) the module-level cache that
+ * `willUpdate()` reads through `loadFlagUrlResolver()`. The real `@aceshooting/lyra-flags` peer's
+ * `flagUrl(code)` never actually rejects (unknown codes just resolve `undefined`), so this is the
+ * only way to exercise a resolver-function rejection — e.g. a network failure fetching a flag
+ * asset — without uninstalling the real package. Not part of the public API; not re-exported from
+ * the root barrel.
+ */
+export function __setFlagUrlResolverForTesting(value) {
+    testFlagUrlResolver = value;
+}
+/**
+ * `<lyra-flag>` — a country/language flag.
+ *
+ * Flag images are shipped by the optional peer package `@aceshooting/lyra-flags`,
+ * not bundled into lyra-ui itself, so importing the core library pulls zero flag
+ * weight. Give it a `country` (ISO 3166-1 alpha-2) or a `language` tag (mapped to
+ * a representative country). While that peer package's `flagUrl()` resolves (or
+ * if it isn't installed), the host carries `aria-busy="true"` and a skeleton
+ * placeholder renders in its place.
+ *
+ * **Bundle-size note:** `country`/`language` resolve through the peer package's
+ * `flagUrl(code)`, which lazily fetches one requested flag at runtime. A
+ * bundler may still emit the complete reachable lazy-chunk graph; use a
+ * literal asset subpath import when the deployment artifact must be pruned.
+ * If you already
+ * have a flag's URL at build time (e.g. from your own literal
+ * `import frUrl from '@aceshooting/lyra-flags/flags/fr.svg?url'`), pass it as
+ * `src` instead to skip the peer-package round trip (and its loading-skeleton
+ * flash) entirely.
+ *
+ * The ~65 flags whose design includes a detailed coat of arms/seal/emblem (e.g. `es`, `pt`) ship
+ * three fidelity tiers; choose one with `variant`: `"compact"` (a tiny WebP raster for icon-scale
+ * use — menu items, language selectors, dense lists), the default `"standard"` (icon-optimized
+ * vector for card/row sizes), or `"detailed"` (the pristine full-detail vector for hero-scale
+ * display). A no-op for every other code — all tiers resolve to the same file. See `variant`'s own
+ * doc.
+ *
+ * @customElement lyra-flag
+ * @example <lyra-flag country="fr"></lyra-flag>
+ * @example <lyra-flag language="en" label="English"></lyra-flag>
+ * @example <lyra-flag src=${frUrl} label="French"></lyra-flag>
+ * @example <lyra-flag country="es" variant="compact"></lyra-flag>
+ * @example <lyra-flag country="es" variant="detailed"></lyra-flag>
+ * @csspart image - The underlying <img>.
+ */
+export class LyraFlag extends LyraElement {
+    constructor() {
+        super(...arguments);
+        /** Render as a circular flag. */
+        this.round = false;
+        /**
+         * @deprecated Use `variant="detailed"` instead. Kept as an alias for one minor cycle; when
+         * `variant` is unset, `detailed` still maps to the detailed tier. Removed in the next major.
+         */
+        this.detailed = false;
+        /** True while the lazy-loaded `@aceshooting/lyra-flags` peer resolver is in flight. */
+        this.loading = true;
+        /**
+         * Bumped on every `willUpdate` pass; captured by each in-flight resolver
+         * `.then()` so a resolution for a `country`/`language` that's since changed
+         * (or been cleared) can recognize itself as stale and no-op instead of
+         * overwriting newer state.
+         */
+        this.resolveToken = 0;
+    }
+    static { this.styles = [LyraElement.styles, styles]; }
+    /** The effective tier to request: an explicit `variant` wins; otherwise the deprecated
+     *  `detailed` boolean is honored; otherwise `"standard"`. */
+    get effectiveVariant() {
+        return this.variant ?? (this.detailed ? 'detailed' : 'standard');
+    }
+    get code() {
+        if (this.country) {
+            return ALPHA2_RE.test(this.country) ? this.country.toLowerCase() : undefined;
+        }
+        if (this.language)
+            return languageToCountry(this.language);
+        return undefined;
+    }
+    willUpdate(changed) {
+        // `this.hasUpdated` (not just `changed`) forces this body to run once on
+        // the very first update even when none of `country`/`language`/`src` is
+        // ever set: an unset optional property's first "assignment" is
+        // undefined -> undefined (no-op to Lit), so none of `changed.has(...)`
+        // would otherwise ever become true for a `<lyra-flag>` that never
+        // receives one, leaving `loading` stuck at its initial `true` forever.
+        if (this.hasUpdated &&
+            !changed.has('country') &&
+            !changed.has('language') &&
+            !changed.has('src') &&
+            !changed.has('variant') &&
+            !changed.has('detailed')) {
+            return;
+        }
+        const token = ++this.resolveToken; // invalidates any in-flight peer resolution either way
+        if (this.src) {
+            this.resolvedSrc = undefined;
+            this.loading = false;
+            return;
+        }
+        const code = this.code;
+        if (!code) {
+            this.resolvedSrc = undefined;
+            this.loading = false;
+            return;
+        }
+        this.loading = true;
+        const variant = this.effectiveVariant;
+        void loadFlagUrlResolver()
+            .then((resolve) => resolve?.(code, variant === 'standard' ? undefined : { variant }))
+            .then((url) => {
+            if (token !== this.resolveToken)
+                return; // superseded by a later country/language/src change
+            this.resolvedSrc = url;
+            this.loading = false;
+        })
+            .catch((err) => {
+            if (token !== this.resolveToken)
+                return; // superseded by a later country/language/src change
+            console.warn(`<lyra-flag> failed to resolve a flag URL for "${code}":`, err);
+            this.resolvedSrc = undefined;
+            this.loading = false;
+        });
+    }
+    updated() {
+        if (this.loading)
+            this.setAttribute('aria-busy', 'true');
+        else
+            this.removeAttribute('aria-busy');
+    }
+    render() {
+        if (this.loading)
+            return html `<lyra-skeleton variant="rect"></lyra-skeleton>`;
+        const url = this.src ?? this.resolvedSrc;
+        if (!url)
+            return html ``;
+        const code = this.code;
+        const alt = this.label ?? (code ? displayNameFor(code) : '');
+        return html `<img part="image" src=${url} alt=${alt} loading="lazy" decoding="async" />`;
+    }
+}
+__decorate([
+    property()
+], LyraFlag.prototype, "country", void 0);
+__decorate([
+    property()
+], LyraFlag.prototype, "language", void 0);
+__decorate([
+    property()
+], LyraFlag.prototype, "src", void 0);
+__decorate([
+    property()
+], LyraFlag.prototype, "label", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraFlag.prototype, "round", void 0);
+__decorate([
+    property()
+], LyraFlag.prototype, "variant", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraFlag.prototype, "detailed", void 0);
+__decorate([
+    state()
+], LyraFlag.prototype, "resolvedSrc", void 0);
+__decorate([
+    state()
+], LyraFlag.prototype, "loading", void 0);
+//# sourceMappingURL=flag.class.js.map

package/dist/components/flag/flag.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag.class.js","sourceRoot":"","sources":["../../../src/components/flag/flag.class.ts"],"names":[],"mappings":"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"}

package/dist/components/flag/flag.d.ts

@@ -1,121 +1,3 @@
-import { type TemplateResult, type PropertyValues } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-import '../skeleton/skeleton.js';
-export type FlagVariant = 'compact' | 'standard' | 'detailed';
-type FlagUrlResolver = (code: string, options?: {
-    variant?: FlagVariant;
-}) => Promise<string | undefined>;
-/**
- * Resolves the optional peer dependency `@aceshooting/lyra-flags`'s `flagUrl`
- * via the given importer (a real dynamic import by default). Uncached and
- * dependency-injectable — unlike `loadFlagUrlResolver()` below — so the
- * caught-error warning path is directly testable without needing to
- * actually uninstall the package.
- */
-export declare function loadFlagUrl(importFlags?: () => Promise<{
-    flagUrl: FlagUrlResolver;
-}>): Promise<FlagUrlResolver | null>;
-/**
- * `<lyra-flag>` — a country/language flag.
- *
- * Flag images are shipped by the optional peer package `@aceshooting/lyra-flags`,
- * not bundled into lyra-ui itself, so importing the core library pulls zero flag
- * weight. Give it a `country` (ISO 3166-1 alpha-2) or a `language` tag (mapped to
- * a representative country). While that peer package's `flagUrl()` resolves (or
- * if it isn't installed), the host carries `aria-busy="true"` and a skeleton
- * placeholder renders in its place.
- *
- * **Bundle-size note:** `country`/`language` resolve through the peer package's
- * `flagUrl(code)`, which is itself genuinely code-split per flag (see that
- * package's docs) — using `<lyra-flag country="fr">` anywhere in an app ships
- * only the flags actually requested at runtime, not all 249. If you already
- * have a flag's URL at build time (e.g. from your own literal
- * `import frUrl from '@aceshooting/lyra-flags/flags/fr.svg?url'`), pass it as
- * `src` instead to skip the peer-package round trip (and its loading-skeleton
- * flash) entirely.
- *
- * The ~65 flags whose design includes a detailed coat of arms/seal/emblem (e.g. `es`, `pt`) ship
- * three fidelity tiers; choose one with `variant`: `"compact"` (a tiny WebP raster for icon-scale
- * use — menu items, language selectors, dense lists), the default `"standard"` (icon-optimized
- * vector for card/row sizes), or `"detailed"` (the pristine full-detail vector for hero-scale
- * display). A no-op for every other code — all tiers resolve to the same file. See `variant`'s own
- * doc.
- *
- * @customElement lyra-flag
- * @example <lyra-flag country="fr"></lyra-flag>
- * @example <lyra-flag language="en" label="English"></lyra-flag>
- * @example <lyra-flag src=${frUrl} label="French"></lyra-flag>
- * @example <lyra-flag country="es" variant="compact"></lyra-flag>
- * @example <lyra-flag country="es" variant="detailed"></lyra-flag>
- * @csspart image - The underlying <img>.
- */
-export declare class LyraFlag extends LyraElement {
-    static styles: import("lit").CSSResultGroup[];
-    /** ISO 3166-1 alpha-2 country code (e.g. `fr`, `us`). Takes precedence over `language`. */
-    country?: string;
-    /** BCP-47-ish language tag (e.g. `en`, `en-US`) resolved to a country flag. */
-    language?: string;
-    /**
-     * A pre-resolved flag image URL — takes precedence over `country`/`language`
-     * and skips the `@aceshooting/lyra-flags` peer-package lookup (and its
-     * loading-skeleton round trip) entirely. See the class doc: mainly useful to
-     * avoid even the small per-flag async hop when you already have the URL at
-     * build time. `label` is effectively required alongside `src` — there's no
-     * `country`/`language` to derive a fallback `alt` from.
-     */
-    src?: string;
-    /**
-     * Accessible label / `alt` text. Defaults to a localized, human-readable
-     * region name derived from the *resolved country code* via
-     * `Intl.DisplayNames` (e.g. `"United Kingdom"`) — for a `language`-only
-     * element (e.g. `language="en"`) that's the mapped country's display name,
-     * not the language tag itself. Falls back to the bare uppercase code if
-     * `Intl.DisplayNames` can't resolve it. Has no default when only `src` is
-     * given (no country/language to derive one from).
-     */
-    label?: string;
-    /** Render as a circular flag. */
-    round: boolean;
-    /**
-     * Which fidelity tier to load, for the ~65 `country`/`language` codes whose source art embeds a
-     * coat of arms/seal/emblem (for every other code all tiers are the same file, so this is a safe
-     * no-op):
-     * - `"compact"` — a tiny WebP raster for icon-scale use (menu items, language selectors, dense
-     *   lists; ~12–28px), where the emblem detail is invisible anyway.
-     * - `"standard"` (default) — the icon-optimized vector, for card/row sizes (~28–96px).
-     * - `"detailed"` — the pristine, full-detail vector, for rendering larger than icon scale (e.g.
-     *   a hero display) where the extra illustrative detail is actually visible.
-     *
-     * Has no effect when `src` is set — a pre-resolved URL is used as-is regardless. Takes precedence
-     * over the deprecated `detailed` boolean.
-     */
-    variant?: FlagVariant;
-    /**
-     * @deprecated Use `variant="detailed"` instead. Kept as an alias for one minor cycle; when
-     * `variant` is unset, `detailed` still maps to the detailed tier. Removed in the next major.
-     */
-    detailed: boolean;
-    /** The effective tier to request: an explicit `variant` wins; otherwise the deprecated
-     *  `detailed` boolean is honored; otherwise `"standard"`. */
-    private get effectiveVariant();
-    private resolvedSrc?;
-    /** True while the lazy-loaded `@aceshooting/lyra-flags` peer resolver is in flight. */
-    private loading;
-    /**
-     * Bumped on every `willUpdate` pass; captured by each in-flight resolver
-     * `.then()` so a resolution for a `country`/`language` that's since changed
-     * (or been cleared) can recognize itself as stale and no-op instead of
-     * overwriting newer state.
-     */
-    private resolveToken;
-    private get code();
-    protected willUpdate(changed: PropertyValues<this>): void;
-    protected updated(): void;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lyra-flag': LyraFlag;
-    }
-}
-export {};
+export * from './flag.class.js';
+import "../skeleton/skeleton.js";
+//# sourceMappingURL=flag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flag.d.ts","sourceRoot":"","sources":["../../../src/components/flag/flag.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAGhC,OAAO,yBAAyB,CAAC"}