flask-construct-ui 0.11.2__tar.gz → 0.11.4__tar.gz

{flask_construct_ui-0.11.2 → flask_construct_ui-0.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flask-construct-ui
-Version: 0.11.2
+Version: 0.11.4
 Summary: A UI toolkit for Flask with CRUD and component features.
 Author-email: Olof Tjerngren <olof@tjerngren.net>
 License-Expression: LGPL-3.0-or-later

{flask_construct_ui-0.11.2 → flask_construct_ui-0.11.4}/flask_construct_ui/auth.py

@@ -291,7 +291,7 @@ class FlaskSecurityAuth(AuthProvider):
 
             return [
                 {
-                    "label": "Sign out",
+                    "label": _t("crud-sign-out", "Sign out"),
                     "url": url_for("security.logout"),
                     "icon": "logout",
                 }
@@ -490,7 +490,7 @@ class FlaskOIDCAuth(AuthProvider):
 
             return [
                 {
-                    "label": "Sign out",
+                    "label": _t("crud-sign-out", "Sign out"),
                     "url": url_for(self.logout_endpoint),
                     "icon": "logout",
                 }

{flask_construct_ui-0.11.2 → flask_construct_ui-0.11.4}/flask_construct_ui/base.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from functools import wraps
+import hashlib
 from importlib.metadata import entry_points
 import inspect
 import json
@@ -140,6 +141,50 @@ def apply_trailing_slash(url, construct):
     return url + "/"
 
 
+# Header carrying the menu fingerprint of an HTML response, so a client whose
+# sidebar was rendered for a different one can refresh it. Mirrors
+# AUTH_STAMP_HEADER; see FlaskConstructUI.menu_stamp.
+MENU_STAMP_HEADER = "X-Construct-Menu"
+
+
+def _copy_menu_entry(entry):
+    """Copy a registered entry deeply enough to be reshaped per request.
+
+    The per-request build filters subitems and merges provider entries into
+    existing groups, so the registered dicts and their ``subitems`` lists must
+    not be shared with it — a filtered submenu would otherwise permanently lose
+    the entries the first user was not allowed to see. Values inside an entry
+    (icons, callables) are shared, since nothing rewrites them.
+    """
+    copy = dict(entry)
+    if "subitems" in copy:
+        copy["subitems"] = [dict(sub) for sub in copy["subitems"]]
+    return copy
+
+
+def _sort_menu(items):
+    """Order entries by weight, keeping registration order within a weight."""
+    items.sort(key=lambda entry: entry.get("weight", 0))
+
+
+def _menu_fingerprint(items):
+    """The parts of a menu a viewer could notice changing.
+
+    Titles, links, icons and nesting — not weights or the callables that
+    produced them, which are invisible once the menu is rendered.
+    """
+    return [
+        [
+            entry.get("type"),
+            entry.get("title"),
+            entry.get("link"),
+            entry.get("icon"),
+            _menu_fingerprint(entry.get("subitems", [])),
+        ]
+        for entry in items
+    ]
+
+
 def livesource(name=None, interval=10):
     def wrap(f):
         f._livesource_name = name or f.__name__
@@ -821,22 +866,26 @@ class ExtensionsPage(ComponentPageBase):
                 ]
             )
 
+        content_comp = (
+            components.Table(
+                headers=[
+                    self.t("extensions-name-col"),
+                    self.t("extensions-package-col"),
+                    self.t("extensions-version-col"),
+                    self.t("extensions-status-col"),
+                    self.t("extensions-desc-col"),
+                ],
+                rows=rows,
+            )
+            if rows
+            else components.Text(content=self.t("extensions-no-extensions"))
+        )
+
         return components.VerticalLayout(
             components=[
                 components.Card(
-                    title="extensions-title",
-                    components=[
-                        components.Table(
-                            headers=[
-                                self.t("extensions-name-col"),
-                                self.t("extensions-package-col"),
-                                self.t("extensions-version-col"),
-                                self.t("extensions-status-col"),
-                                self.t("extensions-desc-col"),
-                            ],
-                            rows=rows,
-                        )
-                    ],
+                    title=self.t("extensions-title"),
+                    components=[content_comp],
                 )
             ]
         )
@@ -862,6 +911,7 @@ class FlaskConstructUI:
         auth=None,
         search=None,
         notifications=None,
+        menu_poll=None,
         discover_extensions=True,
         strict_slashes=None,
         check_trailing_slashes=False,
@@ -869,6 +919,18 @@ class FlaskConstructUI:
     ):
         self._pages = []
         self._menu = []
+        # Callables contributing menu entries at render time; see
+        # add_menu_provider. Each is (fn, key) where key is an optional cheap
+        # fingerprint callable that lets menu_stamp skip building the menu.
+        self._menu_providers = []
+        # True once any registered entry carries visibility rules, so a purely
+        # static app never pays for stamping.
+        self._menu_gated = False
+        # True once a registered entry carries a `visible` predicate. Such an
+        # entry can change on nothing the auth stamp can see, so it rules out
+        # the cheap stamp path below.
+        self._menu_predicates = False
+        self._menu_poll = menu_poll
         self._blueprint_names = set()
         self._pages_by_endpoint = {}
         self._registered_pages = set()
@@ -1002,6 +1064,22 @@ class FlaskConstructUI:
             response.headers.setdefault(AUTH_STAMP_HEADER, auth_stamp(self._auth))
             return response
 
+        @app.after_request
+        def add_menu_stamp(response):
+            # Same problem as the auth stamp, one level down: the sidebar is
+            # outside #main-content, so a fragment response leaves whatever
+            # menu the page was loaded with standing — including one built
+            # before the user joined a group, or before the feed a provider
+            # reads gained an entry. Tagging every HTML response with the menu
+            # it *would* have rendered lets the client notice and reload just
+            # the menu fragment. Static menus never get here.
+            if not self.menu_is_dynamic or "text/html" not in response.content_type:
+                return response
+            stamp = self.menu_stamp
+            if stamp is not None:
+                response.headers.setdefault(MENU_STAMP_HEADER, stamp)
+            return response
+
         # A stash the library's own CRUD forms consume when they render it,
         # but an app template using resumed_value() only reads — so retire it
         # here once the form it belongs to has been submitted successfully.
@@ -1157,51 +1235,70 @@ class FlaskConstructUI:
             self._pages_by_endpoint[page.endpoint] = page
             self._register_page_blueprint(page)
 
-        if self._search is not None or self._notifications is not None:
-            prefix = self.url.rstrip("/") + "/_construct"
-            if self.enforce_trailing_slash and not prefix.endswith("/"):
-                prefix += "/"
-
-            features_bp = Blueprint("construct_features", __name__, url_prefix=prefix)
-            _self = self
-
-            search_url = "/search"
-            notifications_url = "/notifications"
-            if self.enforce_trailing_slash:
-                search_url += "/"
-                notifications_url += "/"
-
-            route_kwargs = {}
-            if self.strict_slashes is not None:
-                route_kwargs["strict_slashes"] = self.strict_slashes
-
-            if self._search is not None:
-                _search = self._search
-
-                @features_bp.route(search_url, **route_kwargs)
-                def search_results():
-                    q = request.args.get("q", "")
-                    results = _search.search(q)
-                    return render_template(
-                        "navbar/search_results.html",
-                        construct=_self,
-                        results=results,
-                        query=q,
-                    )
+        # The features blueprint is registered unconditionally because the menu
+        # fragment route cannot be conditional: providers are normally added
+        # after init_app (`fcu = FlaskConstructUI(app)` first, decorators
+        # after), so anything keyed on menu_is_dynamic here would decide before
+        # the app had its say. Search and notifications keep their own guards
+        # below; the menu route simply serves the static menu when no provider
+        # ever appears.
+        prefix = self.url.rstrip("/") + "/_construct"
+        if self.enforce_trailing_slash and not prefix.endswith("/"):
+            prefix += "/"
+
+        features_bp = Blueprint("construct_features", __name__, url_prefix=prefix)
+        _self = self
+
+        search_url = "/search"
+        notifications_url = "/notifications"
+        menu_url = "/menu"
+        if self.enforce_trailing_slash:
+            search_url += "/"
+            notifications_url += "/"
+            menu_url += "/"
+
+        route_kwargs = {}
+        if self.strict_slashes is not None:
+            route_kwargs["strict_slashes"] = self.strict_slashes
+
+        if self._search is not None:
+            _search = self._search
+
+            @features_bp.route(search_url, **route_kwargs)
+            def search_results():
+                q = request.args.get("q", "")
+                results = _search.search(q)
+                return render_template(
+                    "navbar/search_results.html",
+                    construct=_self,
+                    results=results,
+                    query=q,
+                )
 
-            if self._notifications is not None:
+        if self._notifications is not None:
 
-                @features_bp.route(notifications_url, **route_kwargs)
-                def notifications_fragment():
-                    # Just the #fcu-notifications fragment; Unpoly's up-poll
-                    # reloads it on a timer to keep the count + items fresh.
-                    return render_template(
-                        "navbar/notifications.html",
-                        construct=_self,
-                    )
+            @features_bp.route(notifications_url, **route_kwargs)
+            def notifications_fragment():
+                # Just the #fcu-notifications fragment; Unpoly's up-poll
+                # reloads it on a timer to keep the count + items fresh.
+                return render_template(
+                    "navbar/notifications.html",
+                    construct=_self,
+                )
 
-            self.app.register_blueprint(features_bp)
-            self._blueprint_names.add("construct_features")
+        @features_bp.route(menu_url, **route_kwargs)
+        def menu_fragment():
+            # Just the #fcu-main-menu nav, the same markup the full layout
+            # includes. construct-core.js reloads it through up-source when a
+            # response's menu stamp disagrees with the shell's; up-poll can
+            # drive it on a timer instead.
+            return render_template(
+                "style/_menu.html",
+                construct=_self,
+            )
+
+        self.app.register_blueprint(features_bp)
+        self._blueprint_names.add("construct_features")
 
     def load_extensions(self):
         """Discover and load companion libraries via entry points in the
@@ -1307,7 +1404,15 @@ class FlaskConstructUI:
                 )
         return warnings
 
-    def add_page(self, page, submenu=None, submenu_icon=None):
+    def add_page(
+        self,
+        page,
+        submenu=None,
+        submenu_icon=None,
+        groups=None,
+        visible=None,
+        weight=None,
+    ):
         """Register a page and add it to the navigation menu.
 
         When ``submenu`` is given, the page's menu entry is nested under a
@@ -1316,6 +1421,18 @@ class FlaskConstructUI:
         into the same group, in the order they are added. ``submenu_icon`` sets
         the icon for the group the first time it is created; if omitted, the
         group falls back to the ``folder`` icon.
+
+        ``groups`` and ``visible`` gate the *menu entry* per request (see
+        :meth:`menu`): the entry is listed only for a user in one of ``groups``
+        / only when ``visible()`` returns true. When ``groups`` is omitted the
+        page's own ``required_groups`` is used, so a group-gated page hides its
+        own entry with no extra argument. This is presentation only — the route
+        behind the entry is gated by ``required_groups`` / ``@require_groups``,
+        and an entry left out of the menu is never a substitute for that check.
+
+        ``weight`` orders the entry among its siblings (default 0, ties keep
+        registration order), which is what lets a provider place entries around
+        statically registered pages.
         """
         self._pages.append(page)
         self._blueprint_names.add(page.endpoint)
@@ -1340,6 +1457,17 @@ class FlaskConstructUI:
                 # they need the same normalization the route patterns get —
                 # otherwise every sidebar entry 308-redirects to its own page.
                 menu["link"] = apply_trailing_slash(menu["link"], self)
+                if groups is None:
+                    groups = getattr(page, "required_groups", None)
+                if groups:
+                    menu.setdefault("groups", list(groups))
+                if visible is not None:
+                    menu["visible"] = visible
+                    self._menu_predicates = True
+                if weight is not None:
+                    menu["weight"] = weight
+                if menu.get("groups") or menu.get("visible") is not None:
+                    self._menu_gated = True
                 if submenu is not None:
                     if submenu_icon is None:
                         self._add_to_submenu(submenu, menu)
@@ -1348,17 +1476,64 @@ class FlaskConstructUI:
                 else:
                     self._menu.append(menu)
 
-    def _add_to_submenu(self, title, item, icon="folder"):
+    def add_menu_provider(self, provider, key=None):
+        """Register a callable that contributes menu entries per request.
+
+        ``provider(construct)`` is called once per rendered menu and returns an
+        iterable of entry dicts (``{"type": "item", "title": ..., "icon": ...,
+        "link": ...}``). An entry may carry ``"submenu": "<title>"`` to be
+        placed inside that group — creating it if the group does not exist yet
+        — plus the same ``groups`` / ``visible`` / ``weight`` keys
+        :meth:`add_page` accepts. Titles are translated like any other entry,
+        so a provider may return either literal text or an l10n key.
+
+        Nothing about this is specific to permissions: a provider is simply
+        "code that decides part of the menu at render time", whether that means
+        the groups a user belongs to, their five most recent discussions, or
+        entries pulled from an external feed.
+
+        ``key`` is an optional zero-argument callable returning a cheap value
+        that changes whenever this provider's output would. When *every*
+        provider supplies one, :attr:`menu_stamp` is computed from the keys and
+        the providers never run on requests that do not render the menu. Give a
+        ``key`` to any provider whose work is more than a dict comprehension.
+
+        Returns ``provider``, so it also works as a decorator via
+        :meth:`menu_provider`.
+        """
+        self._menu_providers.append((provider, key))
+        return provider
+
+    def menu_provider(self, key=None):
+        """Decorator form of :meth:`add_menu_provider`.
+
+        Usable bare (``@construct.menu_provider``) or called with a key
+        (``@construct.menu_provider(key=lambda: feed.version)``).
+        """
+        if callable(key):
+            return self.add_menu_provider(key)
+
+        def wrap(fn):
+            return self.add_menu_provider(fn, key=key)
+
+        return wrap
+
+    def _add_to_submenu(self, title, item, icon="folder", items=None):
         """Place ``item`` under the submenu group named ``title``.
 
         Reuses an existing group with the same title if one was already
         created, otherwise appends a new submenu entry at the current position.
+        ``items`` defaults to the statically registered menu; the per-request
+        build passes its own working list so providers merge into the same
+        groups without mutating the registered one.
         """
-        for entry in self._menu:
+        if items is None:
+            items = self._menu
+        for entry in items:
             if entry.get("type") == "submenu" and entry.get("title") == title:
                 entry["subitems"].append(item)
                 return
-        self._menu.append(
+        items.append(
             {
                 "type": "submenu",
                 "title": title,
@@ -1513,7 +1688,142 @@ class FlaskConstructUI:
 
     @property
     def menu(self):
-        return self._menu
+        """The menu as it stands for this request.
+
+        Statically registered entries (:meth:`add_page`) first, then whatever
+        the registered providers contribute, then visibility filtering and
+        ordering. Built once per request and cached on ``g``, so providers run
+        once however many times a template asks for the menu.
+
+        Outside a request context this is the registered menu, unfiltered:
+        every dynamic part is by definition a function of the request (who is
+        asking, what their feed holds), so there is nothing honest to compute
+        without one.
+        """
+        if not has_request_context():
+            return self._menu
+        cached = g.get("_construct_menu", None)
+        if cached is not None:
+            return cached
+        items = [_copy_menu_entry(entry) for entry in self._menu]
+        for provider, _key in self._menu_providers:
+            for entry in provider(self) or []:
+                self._place_entry(items, dict(entry))
+        items = self._visible_entries(items)
+        _sort_menu(items)
+        g._construct_menu = items
+        return items
+
+    def _place_entry(self, items, entry):
+        """Insert a provider-supplied ``entry`` into the working menu."""
+        entry.setdefault("type", "item")
+        if entry.get("link"):
+            entry["link"] = apply_trailing_slash(entry["link"], self)
+        submenu = entry.pop("submenu", None)
+        if submenu is None:
+            items.append(entry)
+            return
+        icon = entry.pop("submenu_icon", None) or "folder"
+        self._add_to_submenu(submenu, entry, icon, items=items)
+
+    def _entry_visible(self, entry):
+        """Whether ``entry`` should be listed for the current request."""
+        visible = entry.get("visible")
+        if visible is not None and not visible():
+            return False
+        groups = entry.get("groups")
+        if not groups:
+            return True
+        if self._auth is None:
+            # Matches the route guards, which only enforce group membership
+            # once an AuthProvider is configured.
+            return True
+        return self._auth.has_groups(groups, entry.get("groups_mode", "any"))
+
+    def _visible_entries(self, items):
+        """Filter ``items`` in place-ish, dropping submenus left empty.
+
+        A group that only held entries this user cannot see is noise — worse,
+        an empty disclosure the user can open to find nothing — so it goes with
+        its last child.
+        """
+        kept = []
+        for entry in items:
+            if not self._entry_visible(entry):
+                continue
+            if entry.get("type") == "submenu":
+                subitems = [
+                    sub for sub in entry.get("subitems", []) if self._entry_visible(sub)
+                ]
+                if not subitems:
+                    continue
+                entry["subitems"] = subitems
+                _sort_menu(subitems)
+            kept.append(entry)
+        return kept
+
+    @property
+    def menu_is_dynamic(self):
+        """Whether this menu can change between requests.
+
+        False for an app that only registers plain pages, and the stamping
+        below is then skipped entirely: no header, no ``data-fcu-menu``, no
+        refresh endpoint, nothing for a static app to pay for.
+        """
+        return bool(self._menu_providers) or self._menu_gated
+
+    @property
+    def menu_stamp(self):
+        """Fingerprint of the menu this request is being served, or None.
+
+        The counterpart of :attr:`auth_stamp`, for the same reason: the sidebar
+        lives outside ``#main-content``, so a fragment response can never bring
+        it up to date on its own. Fragment responses carry this value in the
+        ``X-Construct-Menu`` header and construct-core.js compares it with the
+        ``data-fcu-menu`` the full-page layout stamped on ``<html>``.
+
+        Unlike a stale *auth* shell, a stale menu is not a correctness problem,
+        so the client reloads just the menu fragment rather than the document —
+        a menu entry appearing must not throw anyone out of a half-filled form.
+
+        Cheap path: when every provider declared a ``key``, the stamp is built
+        from those keys plus the auth stamp (which already folds in the groups
+        the gated entries are filtered on) and the menu itself is never built.
+        A registered ``visible`` predicate rules that out — it answers to
+        something no key and no auth stamp describes, so the only honest
+        fingerprint is the menu it produces. (A predicate on a *provider's*
+        entry is the provider's business, and its key is taken to cover it.)
+        """
+        if not self.menu_is_dynamic:
+            return None
+        keys = [key for _provider, key in self._menu_providers]
+        if not self._menu_predicates and all(key is not None for key in keys):
+            source = [auth_stamp(self._auth) if self._auth is not None else ""]
+            source.extend(repr(key()) for key in keys)
+        else:
+            source = _menu_fingerprint(self.menu)
+        return hashlib.sha256(
+            json.dumps(source, default=str).encode("utf-8")
+        ).hexdigest()[:16]
+
+    @property
+    def menu_url(self):
+        """URL of the menu fragment endpoint, or None when the menu is static."""
+        if not self.menu_is_dynamic:
+            return None
+        return apply_trailing_slash(self.url.rstrip("/") + "/_construct/menu", self)
+
+    @property
+    def menu_poll(self):
+        """Interval in ms for polling the menu fragment, or None.
+
+        Only needed by an app that wants an idle page to notice menu changes
+        and has no notifications poll already running — every Unpoly response,
+        that poll's included, carries the stamp that triggers a refresh.
+        """
+        if self._menu_poll is None or not self.menu_is_dynamic:
+            return None
+        return int(self._menu_poll * 1000)
 
     @property
     def titleFromLink(self):
@@ -1524,11 +1834,18 @@ class FlaskConstructUI:
         a ``self.page`` attribute that has never existed on the extension, so
         it raised on every call — harmless while nothing used it, and the cause
         of an empty ``<title>`` once ``page_title`` started depending on it.)
+
+        Reads the *registered* menu, not the per-request one. A heading names
+        the page, and pages are registered; deriving it from the dynamic menu
+        instead would put every ``<h1>`` and ``<title>`` at the mercy of
+        whatever a provider reads — a feed that times out would leave the page
+        nameless — and would make every partial render build a menu it is not
+        going to draw.
         """
         if not has_request_context():
             return ""
         here = request.path.rstrip("/")
-        for item in self.menu:
+        for item in self._menu:
             if item.get("type") == "submenu":
                 for subitem in item.get("subitems", []):
                     link = subitem.get("link")

{flask_construct_ui-0.11.2 → flask_construct_ui-0.11.4}/flask_construct_ui/l10n/en/main.flt

@@ -11,7 +11,7 @@ crud-num-notifications = {$count ->
                        *[other] {$count} Notifications
                        }
 crud-see-all-notifications = See all notifications
-crud-sign-out = Sign-out
+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.
@@ -61,6 +61,7 @@ nav-main = Main navigation
 nav-sidebar = Sidebar
 nav-user-tools = User tools
 nav-search = Search
+nav-search-no-results = No results for "{$query}".
 nav-notifications = Notifications
 nav-tabs = Sections
 nav-pagination = Pagination
@@ -132,6 +133,7 @@ validation-must-be-date = Must be a valid date
 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-keyword = Must match keyword '{$keyword}'
 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
@@ -140,12 +142,14 @@ 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-string-len-unknown = Length constraint is not valid ({$limit})
 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}
+validation-number-val-unknown = Value constraint is not valid ({$limit})
 
 extensions-title = System Extensions
 extensions-name-col = Extension Name
@@ -155,3 +159,6 @@ extensions-status-col = Status
 extensions-desc-col = Details / Entry Point
 extensions-no-extensions = No extensions registered via entry points.
 
+Manage = Manage
+Extensions = Extensions
+

{flask_construct_ui-0.11.2 → flask_construct_ui-0.11.4}/flask_construct_ui/l10n/sv/main.flt

@@ -43,7 +43,7 @@ crud-view-button = Visa
 crud-delete-button = Ta bort
 crud-remove-item = Ta bort
 crud-close = Stäng
-crud-apply-filter = Använd
+crud-apply-filter = Tillämpa
 crud-advanced-filter = Avancerat filter
 crud-simple-search = Enkel sökning
 alert-success = Lyckades
@@ -62,6 +62,7 @@ nav-main = Huvudnavigering
 nav-sidebar = Sidopanel
 nav-user-tools = Användarverktyg
 nav-search = Sök
+nav-search-no-results = Inga resultat för "{$query}".
 nav-notifications = Notifieringar
 nav-tabs = Avsnitt
 nav-pagination = Paginering
@@ -133,6 +134,7 @@ validation-must-be-date = Måste vara ett giltigt datum
 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-keyword = Måste matcha nyckelordet '{$keyword}'
 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
@@ -141,12 +143,14 @@ 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-string-len-unknown = Längdvillkoret är ogiltigt ({$limit})
 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}
+validation-number-val-unknown = Värdevillkoret är ogiltigt ({$limit})
 
 extensions-title = Systemtillägg
 extensions-name-col = Tilläggsnamn
@@ -156,3 +160,6 @@ extensions-status-col = Status
 extensions-desc-col = Detaljer / Entry Point
 extensions-no-extensions = Inga tillägg registrerade via entry points.
 
+Manage = Hantera
+Extensions = Tillägg
+