flask-construct-ui 0.9.5__py3-none-any.whl

flask_construct_ui/forms.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+from flask import current_app
+from . import schema
+
+# --- Server-side form validation -------------------------------------------
+# Structural checks (max length, type parseability, required, enum/set
+# membership) are always enforced before anything is written. ``matches``
+# rules are advisory by default; they are enforced when the field declares
+# ``enforce=True`` or the app sets ``CONSTRUCT_ENFORCE_MATCHES = True``
+# (a per-field ``enforce=False`` overrides the app default).
+
+
+class FormData:
+    """Attribute access over a processed form-data dict, optionally falling
+    back to an existing record — used as the ``row`` for per-row ``matches``
+    rules and to re-render forms with the submitted values after a
+    validation failure."""
+
+    def __init__(self, values, fallback=None):
+        self._values = values
+        self._fallback = fallback
+
+    def __getattr__(self, name):
+        if name.startswith("_"):
+            raise AttributeError(name)
+        values = self.__dict__["_values"]
+        if name in values:
+            return values[name]
+        fallback = self.__dict__["_fallback"]
+        if fallback is not None:
+            return getattr(fallback, name, None)
+        return None
+
+
+def validate_form_data(ds, form_fields, data, row=None, partial=False, skip=()):
+    """Validate processed form data before create/update.
+
+    Returns ``{form input name: ValidationError}`` — empty when valid. With
+    ``partial=True`` (updates) fields absent from ``data`` are treated as
+    unchanged rather than missing.
+    """
+    enforce_default = bool(current_app.config.get("CONSTRUCT_ENFORCE_MATCHES", False))
+    errors = {}
+    list_items = data.get("list_items") or {}
+    for field, type_info in dict(form_fields).items():
+        if field in skip or type_info.readonly or not type_info.visible_form:
+            continue
+        if isinstance(type_info, schema.PK):
+            continue
+        if isinstance(type_info, schema.List):
+            actions = list_items.get(field) or {}
+            sub_schema = type_info.list_class._schema
+            for i, item in enumerate(actions.get("new") or []):
+                item_row = FormData(item)
+                for sub_field, sub_type in sub_schema.items():
+                    if (
+                        sub_type.field_type == "pk"
+                        or sub_type.readonly
+                        or not sub_type.visible_form
+                    ):
+                        continue
+                    err = sub_type.validate_submission(
+                        item.get(sub_field),
+                        row=item_row,
+                        enforce_default=enforce_default,
+                    )
+                    if err:
+                        err.label = sub_type.name
+                        errors[f"{field}-new-{i}-{sub_field}"] = err
+            for item in actions.get("update") or []:
+                item_id = item.get("id")
+                item_row = FormData(item, type_info.list_class().read(item_id))
+                for sub_field, sub_type in sub_schema.items():
+                    if (
+                        sub_type.field_type == "pk"
+                        or sub_type.readonly
+                        or not sub_type.visible_form
+                    ):
+                        continue
+                    if sub_field not in item:
+                        continue
+                    err = sub_type.validate_submission(
+                        item[sub_field], row=item_row, enforce_default=enforce_default
+                    )
+                    if err:
+                        err.label = sub_type.name
+                        errors[f"{field}-{item_id}-{sub_field}"] = err
+            continue
+        if isinstance(type_info, schema.ManyRelated) and type_info.create:
+            staged = (data.get("many_related_new") or {}).get(field) or {}
+            quick_values = staged.get("quick") or []
+            new_items = staged.get("new") or []
+            if type_info.create == "quick" and quick_values:
+                quick_field = type_info.resolve_quick_field()
+                quick_type = type_info.related_class._schema[quick_field]
+                for i, value in enumerate(quick_values):
+                    err = quick_type.validate_submission(
+                        value, row=None, enforce_default=enforce_default
+                    )
+                    if err:
+                        err.label = type_info.name
+                        errors[f"{field}-quicknew-{i}"] = err
+            if type_info.create == "form":
+                for i, item in enumerate(new_items):
+                    item_row = FormData(item)
+                    for sub_field, sub_type in type_info.inline_form_fields():
+                        err = sub_type.validate_submission(
+                            item.get(sub_field),
+                            row=item_row,
+                            enforce_default=enforce_default,
+                        )
+                        if err:
+                            err.label = sub_type.name
+                            errors[f"{field}-newrel-{i}-{sub_field}"] = err
+            if not data.get(field) and (quick_values or new_items):
+                # Staged creations satisfy `required` on the field itself.
+                continue
+        if field not in data:
+            if partial:
+                continue
+            value = None
+        else:
+            value = data[field]
+        err = type_info.validate_submission(
+            value, row=row, enforce_default=enforce_default
+        )
+        if err:
+            err.label = type_info.name
+            errors[field] = err
+    return errors

flask_construct_ui/headless.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+import json
+import uuid
+from flask import Response, stream_with_context
+from markupsafe import Markup, escape
+from typing import Any, Generator, Iterable
+
+
+def sse_event(event: str, data: Any) -> str:
+    """Formats an SSE block for a given event name and data.
+
+    If data is not a string, it will be JSON serialized automatically.
+    """
+    if not isinstance(data, str):
+        data = json.dumps(data)
+    return f"event: {event}\ndata: {data}\n\n"
+
+
+def sse_response(generator: Generator[str, None, None] | Iterable[str]) -> Response:
+    """Returns a Flask response configured for EventSource streaming."""
+    return Response(
+        stream_with_context(generator),
+        mimetype="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+def live_attributes(
+    sse_url: str | None = None,
+    poll_url: str | None = None,
+    interval: int = 10,
+    content_id: str | None = None,
+    format: str = "default",
+    max_lines: int | None = 200,
+) -> str:
+    """Generates the data-live-* attributes for a custom HTML container.
+
+    This can be used on any HTML element to wire up live updates.
+    """
+    attrs = []
+    if sse_url:
+        attrs.append(f'data-live-sse-url="{escape(sse_url)}"')
+    if poll_url:
+        attrs.append(f'data-live-poll-url="{escape(poll_url)}"')
+
+    attrs.append(f'data-live-interval="{interval * 1000}"')
+
+    if content_id:
+        attrs.append(f'data-live-content-id="{escape(content_id)}"')
+
+    if format and format != "default":
+        attrs.append(f'data-live-format="{escape(format)}"')
+        if format == "append":
+            attrs.append(f'data-live-limit="{max_lines if max_lines is not None else 0}"')
+
+    return Markup(" ".join(attrs))  # nosemgrep: explicit-unescape-with-markup  # nosec B704
+
+
+def live_container(
+    content_html: str = "",
+    sse_url: str | None = None,
+    poll_url: str | None = None,
+    interval: int = 10,
+    content_id: str | None = None,
+    format: str = "default",
+    css_class: str | None = None,
+    container_id: str | None = None,
+    max_lines: int | None = 200,
+) -> str:
+    """Renders a fully-formed live update container, including No-JS fallback.
+
+    ``content_html`` is inserted verbatim (it is expected to be HTML); the caller
+    must sanitize any untrusted content before passing it in. The id/class
+    config values are HTML-escaped.
+    """
+    cid = container_id or f"live-headless-{uuid.uuid4().hex[:8]}"
+    target_content_id = content_id or f"live-content-{cid}"
+
+    attrs = live_attributes(
+        sse_url=sse_url,
+        poll_url=poll_url,
+        interval=interval,
+        content_id=target_content_id,
+        format=format,
+        max_lines=max_lines,
+    )
+
+    class_str = (
+        f' class="live-component {escape(css_class)}"'
+        if css_class
+        else ' class="live-component"'
+    )
+
+    # Escape the id/class config values (they may be caller-supplied) so this
+    # helper matches live_attributes(); content_html is intentionally raw — the
+    # caller owns its HTML and is responsible for sanitizing untrusted content.
+    html = (
+        f'<div id="{escape(cid)}"{class_str} {attrs}>\n'
+        f'  <div id="{escape(target_content_id)}" class="live-content">\n'
+        f"    {content_html}\n"
+        f"  </div>\n"
+        f"  <noscript>\n"
+        f'    <meta http-equiv="refresh" content="{interval}">\n'
+        f"  </noscript>\n"
+        f"</div>"
+    )
+    return Markup(html)  # nosemgrep: explicit-unescape-with-markup  # nosec B704

flask_construct_ui/icons.py

@@ -0,0 +1,158 @@
+"""Theme-agnostic icon rendering.
+
+The icon *string* an app passes — a Bootstrap Icons class like ``bi-star`` or a
+Material Symbol ligature like ``star`` — is wrapped in different markup by each
+theme. ``render_icon`` centralises that wrapper choice so a single (eventually
+unified) template tree can emit icons without hard-coding one library's markup.
+
+The wrapper is chosen by an *icon mode*:
+
+  * ``"bootstrap"`` -> ``<i class="bi <name> <extra>"></i>``
+  * ``"material"``  -> ``<span class="material-symbols-outlined <extra>"><name></span>``
+
+A structural theme has a default mode; a *design* may override it, so the
+``adminlte`` design layered on the whitelabel theme opts back into
+Bootstrap-Icons markup (the look of the former adminlte3 theme it replaced).
+
+The library refers to its own icons by *semantic* names (``"save"``, ``"back"``,
+…) collected in the ``ICONS`` registry below, which maps each to a concrete
+glyph per icon set. ``render_icon`` translates the semantic name to the active
+mode's glyph *and* wraps it in that mode's markup — so one template renders
+correctly under either icon set. Names not in the registry (app-supplied icon
+strings) pass through verbatim.
+"""
+
+from flask import g
+from markupsafe import Markup
+
+# Default icon mode per structural theme. `whitelabel` is the only structural
+# theme; bootstrap-icon rendering is reached via the `adminlte` design (see
+# DESIGN_ICON_MODE below).
+THEME_ICON_MODE = {
+    "whitelabel": "material",
+}
+
+# Optional per-design override (design name -> icon mode). Lets a design pick an
+# icon library independently of the theme it skins. The ``adminlte`` design
+# (the whitelabel skin that replaced the old adminlte3 theme) opts back into
+# Bootstrap Icons so its UI matches the original AdminLTE look.
+DESIGN_ICON_MODE: dict[str, str] = {
+    "adminlte": "bootstrap",
+}
+
+DEFAULT_ICON_MODE = "material"
+
+# --- The icon translation registry ---------------------------------------
+#
+# The library refers to its own icons by *semantic* names; this table maps each
+# to a concrete glyph in every supported icon set. ``render_icon`` looks a
+# semantic name up here and emits the glyph for the active icon mode, so the
+# same template renders correctly whichever icon set a theme/design selects.
+#
+# Every entry MUST provide both modes. When a feature needs a new icon, add a
+# row here (pick a Bootstrap Icons class and a Material Symbol name) rather than
+# hard-coding a glyph in a template. Names not found here are passed through
+# verbatim (e.g. app-supplied icons), wrapped in the active mode's markup.
+ICONS = {
+    "back": {"bootstrap": "bi-arrow-left", "material": "arrow_back"},
+    "return": {"bootstrap": "bi-arrow-return-left", "material": "keyboard_return"},
+    "notifications": {"bootstrap": "bi-bell-fill", "material": "notifications"},
+    "check": {"bootstrap": "bi-check-circle-fill", "material": "check_circle"},
+    "folder": {"bootstrap": "bi-folder", "material": "folder"},
+    "filter": {"bootstrap": "bi-funnel", "material": "filter_alt"},
+    "home": {"bootstrap": "bi-house", "material": "home"},
+    "lock": {"bootstrap": "bi-lock-fill", "material": "lock"},
+    "edit": {"bootstrap": "bi-pencil-fill", "material": "edit"},
+    "add": {"bootstrap": "bi-plus-lg", "material": "add"},
+    "save": {"bootstrap": "bi-save-fill", "material": "save"},
+    "search": {"bootstrap": "bi-search", "material": "search"},
+    "delete": {"bootstrap": "bi-trash-fill", "material": "delete"},
+    "cancel": {"bootstrap": "bi-x-circle-fill", "material": "cancel"},
+    "close": {"bootstrap": "bi-x-lg", "material": "close"},
+    "page": {"bootstrap": "bi-activity", "material": "label"},
+    "list": {"bootstrap": "bi-list-ul", "material": "list"},
+    "logout": {"bootstrap": "bi-box-arrow-right", "material": "logout"},
+    "expand": {"bootstrap": "bi-chevron-right", "material": "chevron_right"},
+    "settings": {"bootstrap": "bi-gear-fill", "material": "settings"},
+    "extension": {"bootstrap": "bi-puzzle-fill", "material": "extension"},
+}
+
+
+def register_icons(icons):
+    """Register additional semantic icons (e.g. from a companion library).
+
+    ``icons`` maps each semantic name to a dict providing **both** icon modes,
+    e.g. ``{"profile": {"bootstrap": "bi-person", "material": "person"}}``.
+    Entries are merged into the global ``ICONS`` registry, overriding any
+    existing row with the same name. A ``ValueError`` is raised when a mode is
+    missing, so a half-defined icon can't silently render blank under the other
+    icon set. Returns the names registered.
+    """
+    for name, glyphs in icons.items():
+        missing = {"bootstrap", "material"} - set(glyphs)
+        if missing:
+            raise ValueError(
+                f"icon {name!r} is missing mode(s) {sorted(missing)}; both "
+                "'bootstrap' and 'material' glyphs are required"
+            )
+        ICONS[name] = {
+            "bootstrap": glyphs["bootstrap"],
+            "material": glyphs["material"],
+        }
+    return list(icons)
+
+
+def resolve_glyph(name, mode):
+    """Resolve a semantic icon name to a concrete glyph for ``mode``.
+
+    Unknown names pass through unchanged (covers app-supplied icon strings).
+    """
+    entry = ICONS.get(name)
+    return entry[mode] if entry else name
+
+
+def resolve_icon_mode(theme=None, design=None):
+    """Resolve the active icon mode: a design override wins, else the theme."""
+    if design and design in DESIGN_ICON_MODE:
+        return DESIGN_ICON_MODE[design]
+    return THEME_ICON_MODE.get(theme, DEFAULT_ICON_MODE)
+
+
+def _current_icon_mode():
+    """Resolve the icon mode for the active request.
+
+    Prefers the live ``construct`` (which folds in any design override); falls
+    back to the bare theme on ``g`` for contexts that render components without
+    a full ``construct`` in scope (e.g. standalone component rendering).
+    """
+    construct = getattr(g, "construct", None)
+    if construct is not None:
+        return construct.icon_mode
+    return THEME_ICON_MODE.get(getattr(g, "construct_theme", None), DEFAULT_ICON_MODE)
+
+
+def render_icon(name, default=None, cls="", style="", mode=None):
+    """Render an icon as theme-appropriate, escaped HTML.
+
+    ``name``    semantic icon name (see ``ICONS``) or a raw glyph; a falsy value
+                falls back to ``default``. Semantic names are translated to the
+                active mode's glyph; unknown names pass through verbatim.
+    ``default`` icon used when ``name`` is empty.
+    ``cls``     extra CSS classes appended to the wrapper element.
+    ``style``   inline style applied to the wrapper element.
+    ``mode``    force a specific icon mode; defaults to the active request's.
+    """
+    name = (name or default or "").strip()
+    if not name:
+        return Markup("")
+    if mode is None:
+        mode = _current_icon_mode()
+    glyph = resolve_glyph(name, mode)
+    extra = cls.strip()
+    style_attr = Markup(' style="{}"').format(style) if style.strip() else Markup("")
+    if mode == "bootstrap":
+        classes = "bi " + glyph + ((" " + extra) if extra else "")
+        return Markup('<i class="{}"{}></i>').format(classes, style_attr)
+    # material (default)
+    classes = "material-symbols-outlined" + ((" " + extra) if extra else "")
+    return Markup('<span class="{}"{}>{}</span>').format(classes, style_attr, glyph)

flask_construct_ui/l10n/en/main.flt

@@ -0,0 +1,82 @@
+crud-edit-rec = Edit {$recname}
+crud-create-rec = Create New {$recname}
+crud-enter-field = Enter {$fieldname}
+crud-create-button = Create
+crud-save-button = Save
+crud-cancel-button = Cancel
+crud-action-title = Actions
+crud-num-notifications = {$count ->
+                       [one] 1 Notification
+                       *[other] {$count} Notifications
+                       }
+crud-see-all-notifications = See all notifications
+crud-sign-out = Sign-out
+crud-error-creating-item = Error creating item.
+crud-validation-errors = Please correct the errors below:
+crud-error-updating-item = Error updating item.
+crud-confirm-delete = Are you sure you want to delete this item?
+crud-error-deleting-item = Error deleting item.
+crud-error-not-found = Item not found.
+crud-item-created = Item created successfully.
+crud-item-updated = Item updated successfully.
+crud-item-deleted = Item deleted successfully.
+crud-search-all = Search all fields
+crud-no-items-found = No items found
+crud-add-new-item = Add new item
+crud-new-item = New item
+crud-select = Select
+crud-search = Search...
+crud-change = Change
+crud-enter-new-value = Enter new value
+crud-quick-add = Add "{$value}"
+crud-pending-new = (new)
+crud-back-button = Back
+crud-edit-tab = Edit
+live-not-updating = Not updating
+
+auth-login-required = You must log in to access this page.
+auth-access-denied = You do not have permission to access this resource.
+auth-forbidden-title = Access denied
+auth-forbidden-message = You do not have permission to view this page.
+auth-back-home = Back to start
+
+validation-field-required = This field is required
+validation-must-be-string = Must be a string
+validation-must-be-alpha = Must contain only letters
+validation-must-be-alphanumeric = Must contain only letters and digits
+validation-must-be-email = Must be a valid email address
+validation-must-be-ip = Must be a valid IP address
+validation-must-be-url = Must be a valid URL
+validation-must-be-domain = Must be a valid domain
+validation-must-be-capitalize = Must be capitalized
+validation-must-be-lower = Must be lowercase
+validation-must-be-upper = Must be uppercase
+validation-must-be-trim = Must not have leading or trailing whitespace
+validation-must-be-number = Must be a number
+validation-must-be-integer = Must be an integer
+validation-must-be-datetime = Must be a valid date/time
+validation-must-be-exactly = Must be exactly '{$literal}'
+validation-must-match-pattern = Must match pattern /{$pattern}/
+validation-must-match-one = Must satisfy one of the options
+validation-must-be-one-of = Must be one of: {$options}
+validation-string-len-greater = Length must be greater than {$limit} characters
+validation-string-len-less = Length must be less than {$limit} characters
+validation-string-len-equal = Length must be equal to {$limit} characters
+validation-string-len-not-equal = Length must not be equal to {$limit} characters
+validation-string-len-at-least = Length must be at least {$limit} characters
+validation-string-len-at-most = Length must be at most {$limit} characters
+validation-number-val-greater = Value must be greater than {$limit}
+validation-number-val-less = Value must be less than {$limit}
+validation-number-val-equal = Value must be equal to {$limit}
+validation-number-val-not-equal = Value must not be equal to {$limit}
+validation-number-val-at-least = Value must be at least {$limit}
+validation-number-val-at-most = Value must be at most {$limit}
+
+extensions-title = System Extensions
+extensions-name-col = Extension Name
+extensions-package-col = Package
+extensions-version-col = Version
+extensions-status-col = Status
+extensions-desc-col = Details / Entry Point
+extensions-no-extensions = No extensions registered via entry points.
+

flask_construct_ui/l10n/sv/main.flt

@@ -0,0 +1,82 @@
+crud-edit-rec = Redigera {$recname}
+crud-create-rec = Skapa ny {$recname}
+crud-enter-field = Ange {$fieldname}
+crud-create-button = Skapa
+crud-save-button = Spara
+crud-cancel-button = Avbryt
+crud-action-title = Åtgärder
+crud-num-notifications = {$count ->
+                       [one] 1 notifiering
+                       *[other] {$count} notifieringar
+                       }
+crud-see-all-notifications = Se alla notifieringar
+crud-sign-out = Logga ut
+crud-error-creating-item = Fel vid skapande av post.
+crud-validation-errors = Rätta felen nedan:
+crud-error-updating-item = Fel vid uppdatering av post.
+crud-confirm-delete = Är du säker på att du vill ta bort den här posten?
+crud-error-deleting-item = Fel vid borttagning av post.
+crud-error-not-found = Posten hittades inte.
+crud-item-created = Posten skapades framgångsrikt.
+crud-item-updated = Posten uppdaterades framgångsrikt.
+crud-item-deleted = Posten togs bort framgångsrikt.
+crud-search-all = Sök alla fält
+crud-no-items-found = Inga poster hittades
+crud-add-new-item = Lägg till ny post
+crud-new-item = Ny post
+crud-select = Välj
+crud-search = Sök...
+crud-change = Ändra
+crud-enter-new-value = Ange nytt värde
+crud-quick-add = Lägg till "{$value}"
+crud-pending-new = (ny)
+crud-back-button = Tillbaka
+crud-edit-tab = Redigera
+live-not-updating = Uppdateras inte
+
+auth-login-required = Du måste logga in för att komma åt den här sidan.
+auth-access-denied = Du har inte behörighet att komma åt den här resursen.
+auth-forbidden-title = Åtkomst nekad
+auth-forbidden-message = Du har inte behörighet att visa den här sidan.
+auth-back-home = Tillbaka till start
+
+validation-field-required = Detta fält är obligatoriskt
+validation-must-be-string = Måste vara en sträng
+validation-must-be-alpha = Måste innehålla endast bokstäver
+validation-must-be-alphanumeric = Måste innehålla endast bokstäver och siffror
+validation-must-be-email = Måste vara en giltig e-postadress
+validation-must-be-ip = Måste vara en giltig IP-adress
+validation-must-be-url = Måste vara en giltig webbadress
+validation-must-be-domain = Måste vara en giltig domän
+validation-must-be-capitalize = Måste börja med stor bokstav
+validation-must-be-lower = Måste vara gemener
+validation-must-be-upper = Måste vara versaler
+validation-must-be-trim = Får inte innehålla inledande eller avslutande mellanslag
+validation-must-be-number = Måste vara ett nummer
+validation-must-be-integer = Måste vara ett heltal
+validation-must-be-datetime = Måste vara ett giltigt datum/klockslag
+validation-must-be-exactly = Måste vara exakt '{$literal}'
+validation-must-match-pattern = Måste matcha mönstret /{$pattern}/
+validation-must-match-one = Måste uppfylla ett av alternativen
+validation-must-be-one-of = Måste vara ett av: {$options}
+validation-string-len-greater = Längden måste vara större än {$limit} tecken
+validation-string-len-less = Längden måste vara mindre än {$limit} tecken
+validation-string-len-equal = Längden måste vara exakt {$limit} tecken
+validation-string-len-not-equal = Längden får inte vara {$limit} tecken
+validation-string-len-at-least = Längden måste vara minst {$limit} tecken
+validation-string-len-at-most = Längden får vara högst {$limit} tecken
+validation-number-val-greater = Värdet måste vara större än {$limit}
+validation-number-val-less = Värdet måste vara mindre än {$limit}
+validation-number-val-equal = Värdet måste vara lika med {$limit}
+validation-number-val-not-equal = Värdet får inte vara lika med {$limit}
+validation-number-val-at-least = Värdet måste vara minst {$limit}
+validation-number-val-at-most = Värdet får vara högst {$limit}
+
+extensions-title = Systemtillägg
+extensions-name-col = Tilläggsnamn
+extensions-package-col = Paket
+extensions-version-col = Version
+extensions-status-col = Status
+extensions-desc-col = Detaljer / Entry Point
+extensions-no-extensions = Inga tillägg registrerade via entry points.
+

flask_construct_ui/language.py

@@ -0,0 +1,100 @@
+import os
+from flask import g, request, current_app
+from fluent.runtime import FluentBundle
+from fluent.syntax.parser import FluentParser
+
+
+LOCALE_MAPPING = {
+    "en": "en_US.UTF-8",
+    "sv": "sv_SE.UTF-8",
+    "de": "de_DE.UTF-8",
+    "fr": "fr_FR.UTF-8",
+    "es": "es_ES.UTF-8",
+    "zh": "zh_CN.UTF-8",
+    "ja": "ja_JP.UTF-8",
+}
+
+
+def set_language_from_browser():
+    g.language = request.accept_languages.best_match(current_app.l10n.languages)
+
+
+class Translator:
+    """
+    Flask integrated format_value call.
+    """
+
+    languages = []
+    translations = {}
+
+    def t(self, msg_id, args=None):
+        # Fallback to English if the user's language is not available (or not
+        # yet resolved — e.g. a before_request short-circuits with a translated
+        # response before set_language_from_browser runs).
+        lang = g.get("language", None)
+        bundle = self.translations.get(lang, self.translations.get("en"))
+        if not bundle:
+            return msg_id
+        if not bundle.has_message(msg_id):
+            return msg_id
+        message = bundle.get_message(msg_id)
+        if message and message.value:
+            value, errors = bundle.format_pattern(message.value, args)
+            if errors:
+                print(f"Fluent translation errors for '{msg_id}': {errors} - {value}")
+            return value
+
+        # Return ID as default
+        return msg_id
+
+    def format_value(self, msg_id, args=None):
+        return self.t(msg_id, args)
+
+    def set_languages(self, paths):
+        if isinstance(paths, str):
+            paths = [paths]
+
+        # Collect the union of available language codes across all search
+        # paths, preserving first-seen order. (Previously only the first path
+        # with any language dirs was consulted, which dropped languages shipped
+        # solely by a later path — e.g. a companion library's l10n dir.)
+        self.translations = {}
+        self.languages = []
+        for p in paths:
+            if os.path.isdir(p):
+                try:
+                    for fldr in sorted(next(os.walk(p))[1]):
+                        if len(fldr) in (2, 5) and fldr not in self.languages:
+                            self.languages.append(fldr)
+                except StopIteration:
+                    pass
+
+        parser = FluentParser()
+
+        # For each language, load all .flt files from all paths
+        for lng in self.languages:
+            all_ftl_content = []
+            for p in paths:
+                locale_path = os.path.join(p, lng)
+                if os.path.isdir(locale_path):
+                    for filename in os.listdir(locale_path):
+                        if filename.endswith(".flt"):
+                            try:
+                                with open(
+                                    os.path.join(locale_path, filename),
+                                    "r",
+                                    encoding="utf-8",
+                                ) as f:
+                                    all_ftl_content.append(f.read())
+                            except IOError:
+                                continue
+
+            if not all_ftl_content:
+                continue
+
+            concatenated_content = "\n".join(all_ftl_content)
+
+            bundle = FluentBundle([lng], use_isolating=False)
+            resource = parser.parse(concatenated_content)
+            bundle.add_resource(resource)
+            self.translations[lng] = bundle