workpeg 0.97.2__tar.gz → 0.98.0__tar.gz

{workpeg-0.97.2/src/workpeg.egg-info → workpeg-0.98.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.97.2
+Version: 0.98.0
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.97.2 → workpeg-0.98.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "workpeg"
-version = "0.97.2"
+version = "0.98.0"
 description = "Workpeg function runtime and SDK"
 readme = "README.md"
 requires-python = ">=3.10"

{workpeg-0.97.2 → workpeg-0.98.0}/src/workpeg/ui/build.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import gzip
 import hashlib
 import html
+import re
 import shutil
 from pathlib import Path
 from urllib.parse import urlparse
@@ -85,6 +87,112 @@ def _icons_version(bundled: bool) -> str:
         return "0"
 
 
+#: A gzip of the icon source, packaged INTO the wheel (~1 MB vs the 26 MB raw,
+#: which stays excluded). It lets a wheel-only production build subset icons.css
+#: without carrying the full sheet on disk. Dev/editable installs read the raw
+#: file directly; either way the build ships only the tiny per-app subset.
+_ICONS_CSS_GZ = _ICONS_CSS.parent / "icons.css.gz"
+
+#: (source identity) -> (base rules, {icon-name: its rules}), so a watch rebuild
+#: parses the ~26 MB sheet once, not per save. And the runtime's own icon set.
+_icon_rules_memo: "dict[tuple, tuple]" = {}
+_runtime_base_memo: "set[str] | None" = None
+
+
+def _icons_source_key() -> "tuple | None":
+    """A cheap identity for the icon source (stat only, no read) — the raw
+    checkout copy preferred, else the packaged gzip; None when neither exists."""
+    if _ICONS_CSS.is_file():
+        st = _ICONS_CSS.stat()
+        return ("raw", st.st_mtime_ns, st.st_size)
+    if _ICONS_CSS_GZ.is_file():
+        st = _ICONS_CSS_GZ.stat()
+        return ("gz", st.st_mtime_ns, st.st_size)
+    return None
+
+
+def _read_icons_source() -> str:
+    """The full icon stylesheet text — the raw file, or the decompressed gzip."""
+    if _ICONS_CSS.is_file():
+        return _ICONS_CSS.read_text(encoding="utf-8")
+    return gzip.decompress(_ICONS_CSS_GZ.read_bytes()).decode("utf-8")
+
+
+def _icon_rule_index() -> "tuple | None":
+    """Parse the icon source into ``(base_rules, {name: its_rules})`` once,
+    memoized by source identity. Each ``.ti-NAME`` rule (and its ``.ti-thin`` /
+    ``.ti-bolder`` weight variants) is filed under NAME; rules with no
+    icon-specific class (the base ``.ti``) are base. ``{`` / ``}`` appear only as
+    rule delimiters — the SVG data-URIs are percent-encoded — so a flat regex
+    split is safe. Returns None when no icon source is present."""
+    key = _icons_source_key()
+    if key is None:
+        return None
+    if key in _icon_rules_memo:
+        return _icon_rules_memo[key]
+    text = _read_icons_source()
+    base: "list[str]" = []
+    per: "dict[str, list[str]]" = {}
+    for m in re.finditer(r"([^{}]+)\{([^{}]*)\}", text):
+        rule = m.group(0)
+        names = [n for n in re.findall(r"\.ti-([a-z0-9-]+)", m.group(1))
+                 if n not in ("thin", "bolder")]
+        if not names:
+            base.append(rule)
+        else:
+            for n in set(names):
+                per.setdefault(n, []).append(rule)
+    index = ("".join(base), {n: "".join(r) for n, r in per.items()})
+    _icon_rules_memo.clear()      # one live entry is plenty
+    _icon_rules_memo[key] = index
+    return index
+
+
+def _runtime_base_icons() -> "set[str]":
+    """Icons the runtime bundles render themselves (the Scaffold chrome, the AI
+    surface, Icon fallbacks) — scanned from the runtime JS so the base set stays
+    in sync automatically, and always kept in a subset so the chrome renders.
+    Over-matching is harmless: only names that exist in the icon source are
+    emitted when subsetting."""
+    global _runtime_base_memo
+    if _runtime_base_memo is not None:
+        return _runtime_base_memo
+    names: "set[str]" = set()
+    for p in (_RUNTIME_JS, _SCAFFOLD_JS, _AI_JS):
+        if not p.is_file():
+            continue
+        txt = p.read_text(encoding="utf-8")
+        # The chrome names icons in many forms — icon("x"), icon: "x",
+        # topAction("edit"), iconBtn("refresh"), ti-history — so collect EVERY
+        # icon-shaped quoted string (and the ti-<name> classes). Over-matching
+        # is harmless: only names present in the icon source are emitted when
+        # subsetting, so non-icon strings ("click", "flex", …) drop out.
+        names.update(re.findall(r"""["']([a-z][a-z0-9-]*)["']""", txt))
+        names.update(re.findall(r"\bti-([a-z0-9-]+)\b", txt))
+    names -= {"thin", "bolder", "filled"}
+    # Selected/active states concatenate a "-filled" suffix (ti- + base +
+    # "-filled"), e.g. the thumb-up/down feedback — include those variants too.
+    names |= {n + "-filled" for n in tuple(names)}
+    _runtime_base_memo = names
+    return names
+
+
+def _subset_icons_css(keep: "set[str]") -> "str | None":
+    """The icon stylesheet trimmed to ``keep`` plus the runtime's own icons —
+    the base ``.ti`` rules followed by only the used icons' rules. None when no
+    icon source is available (the caller then links the CDN full set)."""
+    index = _icon_rule_index()
+    if index is None:
+        return None
+    base, per = index
+    parts = [base]
+    for name in sorted(keep | _runtime_base_icons()):
+        rules = per.get(name)
+        if rules:
+            parts.append(rules)
+    return "".join(parts)
+
+
 def build_ui(
     source_path: str,
     output_dir: str = "dist",
@@ -106,7 +214,8 @@ def build_ui(
     if public.is_dir():
         shutil.copytree(public, out, dirs_exist_ok=True)
 
-    ir = ASTParser().parse_file(str(source))
+    parser = ASTParser()
+    ir = parser.parse_file(str(source))
     gen = JSGenerator()
     js = gen.generate(ir)
     runtime = _RUNTIME_JS.read_text(encoding="utf-8")
@@ -156,25 +265,42 @@ def build_ui(
         (out / "ai.js").write_text(ai_js, encoding="utf-8")
     if scaffold_js:
         (out / "scaffold.js").write_text(scaffold_js, encoding="utf-8")
+    # Icon stylesheet. When the app's icons are all static, subset the sheet to
+    # just those (+ the runtime's own icons) and ship the tiny result — a page
+    # then loads a few KB instead of the ~26 MB full set. Works from the raw
+    # file (dev) or the packaged gzip (wheel). Dynamic icon names, or no icon
+    # source at all, fall back to the CDN full set (a dev build with the raw
+    # file still bundles it locally so it works offline).
     icons_href = ICONS_CDN
-    bundled_icons = bundle_icons and gen.uses_icons and _ICONS_CSS.is_file()
-    if bundled_icons:
-        # Dev builds ship the packaged stylesheet next to the app (refreshed
-        # only when the package copy is newer, so watch rebuilds don't rewrite
-        # ~27 MB per save) and link it locally — any static server works.
-        # Installed wheels don't carry the file (kept out to stay small), so
-        # they fall through to the CDN link above.
+    icons_ver = _icons_version(False) if gen.uses_icons else ""
+    if gen.uses_icons and not parser.dynamic_icons:
+        subset = _subset_icons_css(parser.icon_names)
+        if subset is not None:
+            (out / "icons.css").write_text(subset, encoding="utf-8")
+            icons_href = ICONS_HREF
+            icons_ver = hashlib.sha1(subset.encode("utf-8")).hexdigest()[:8]
+    elif bundle_icons and gen.uses_icons and _ICONS_CSS.is_file():
+        # Dynamic icon names in a dev build: can't subset, so bundle the full
+        # local sheet (refreshed only when newer, so a watch rebuild doesn't
+        # rewrite ~26 MB per save). Production links the CDN copy above.
         icons_href = ICONS_HREF
         target = out / "icons.css"
+        # Size-aware, not mtime-only: a prior build may have left a KB-sized
+        # SUBSET here (static → then edited to a dynamic icon), whose mtime is
+        # newer than the source — a size mismatch forces the full sheet back in.
+        # The full → full fast path (equal size, copy2-preserved mtime) still
+        # skips the 26 MB rewrite on a watch save.
         if (not target.exists()
+                or target.stat().st_size != _ICONS_CSS.stat().st_size
                 or target.stat().st_mtime < _ICONS_CSS.stat().st_mtime):
             shutil.copy2(_ICONS_CSS, target)
+        icons_ver = _icons_version(True)
     (out / "index.html").write_text(
         _gen_html(
             ir.name, ns, ver,
             uses_icons=gen.uses_icons,
             icons_href=icons_href,
-            icons_ver=_icons_version(bundled_icons) if gen.uses_icons else "",
+            icons_ver=icons_ver,
             fonts=getattr(ir, "fonts", None),
         ),
         encoding="utf-8",

{workpeg-0.97.2 → workpeg-0.98.0}/src/workpeg/ui/compiler/ast_parser.py

@@ -84,6 +84,12 @@ _WORKPEG_SESSION_HELPERS = {
 }
 
 
+def _is_str_const(node: "ast.AST | None") -> bool:
+    """True when *node* is a string literal (an ``ast.Constant`` holding a str)
+    — used by the icon-literal scan to pick out ``icon="…"`` values."""
+    return isinstance(node, ast.Constant) and isinstance(node.value, str)
+
+
 def _is_workpeg_host(url: str) -> bool:
     """True when *url* targets a Workpeg-owned host — ``workpeg`` as the
     REGISTRABLE label, the one right before the TLD (workpeg.com, *.workpeg.io,
@@ -447,6 +453,11 @@ class ASTParser:
     _current_props: frozenset = frozenset()
     _current_methods: frozenset = frozenset()
     _root_base_dir: "str | None" = None
+    #: Comprehension loop vars in scope that iterate a STATICALLY known set — a
+    #: list/tuple literal, or a component prop fed literals at call sites. An
+    #: icon named through one is collectable (not runtime-dynamic); a loop var
+    #: over State / a call is NOT here, so the build keeps the full sheet.
+    _safe_loop_vars: frozenset = frozenset()
 
     def __init__(self) -> None:
         self._components: dict[str, "ComponentIR | None"] = {}
@@ -483,6 +494,15 @@ class ASTParser:
         # instead of "<unknown>".
         tree = ast.parse(source, filename=filename or "<unknown>")
 
+        # Icon subsetting: the set of literal icon names this build renders (so
+        # build.py can trim icons.css to just those), and whether any icon name
+        # is state-derived (then the full sheet is kept). Reset per parse and
+        # accumulated across the entry file + every imported/page module below.
+        self.icon_names = set()
+        self.dynamic_icons = False
+        self._safe_loop_vars = frozenset()
+        self._scan_icon_literals(tree)
+
         # Collect every class definition so Route entries can cross-reference them.
         class_defs: dict[str, ast.ClassDef] = {}
         for node in ast.walk(tree):
@@ -995,6 +1015,7 @@ class ASTParser:
     ) -> "tuple[dict[str, ast.ClassDef], dict[str, str], dict[str, Any]]":
         with open(file_path) as f:
             tree = ast.parse(f.read(), filename=_display_path(file_path))
+        self._scan_icon_literals(tree)   # icon literals in imported modules
         cdefs = {
             n.name: n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)
         }
@@ -1013,6 +1034,7 @@ class ASTParser:
         extra: list[Any] = []   # positional args beyond the named props
         for i, a in enumerate(node.args):
             if i < len(comp.props):
+                self._note_component_icon_prop(comp.props[i], a, scope)
                 args[comp.props[i]] = self._parse_prop_value(a, scope)
             else:
                 extra.append(self._parse_prop_value(a, scope))
@@ -1039,6 +1061,7 @@ class ASTParser:
                 raise UnsupportedSyntaxError(
                     f"{comp.name}() has no prop '{kw.arg}'"
                 )
+            self._note_component_icon_prop(kw.arg, kw.value, scope)
             args[kw.arg] = self._parse_prop_value(kw.value, scope)
         # Fill omitted parameters from their literal __init__ defaults, the
         # way Python would — so NavItem(label, href) really gets icon="circle".
@@ -2211,7 +2234,7 @@ class ASTParser:
             raise UnsupportedSyntaxError(
                 "a canvas comprehension supports a single 'for' clause"
             )
-        params, inner, iterable = self._parse_comp_target(gens[0], scope)
+        params, inner, iterable, _ = self._parse_comp_target(gens[0], scope)
         cond = self._and_conditions(gens[0].ifs, inner) if gens[0].ifs else None
         elt = self._parse_canvas_op(comp.elt, inner)
         return WidgetIR(type="__each", props={
@@ -2684,6 +2707,7 @@ class ASTParser:
             source = f.read()
         try:
             tree = ast.parse(source, filename=display)
+            self._scan_icon_literals(tree)   # icon literals in the page module
             class_defs: dict[str, ast.ClassDef] = {}
             for node in ast.walk(tree):
                 if isinstance(node, ast.ClassDef):
@@ -3105,7 +3129,7 @@ class ASTParser:
         fake = ast.comprehension(
             target=stmt.target, iter=stmt.iter, ifs=[], is_async=0
         )
-        params, inner_scope, iterable = self._parse_comp_target(fake, scope)
+        params, inner_scope, iterable, _ = self._parse_comp_target(fake, scope)
 
         body_locals = set(local_vars) | set(params)
         body = self._parse_block(stmt.body, body_locals, method_name)
@@ -4461,7 +4485,7 @@ class ASTParser:
                 f"{fn}() supports a single 'for' clause"
             )
         comp = gen.generators[0]
-        params, inner_scope, iterable = self._parse_comp_target(comp, scope)
+        params, inner_scope, iterable, _ = self._parse_comp_target(comp, scope)
         if comp.ifs:
             cond = self._and_conditions(comp.ifs, inner_scope)
             iterable = {"expr": "method", "target": iterable, "name": "filter",
@@ -4570,34 +4594,43 @@ class ASTParser:
         self, elt: ast.expr, gens: list, i: int, scope: frozenset
     ) -> Any:
         gen = gens[i]
-        params, inner_scope, base = self._parse_comp_target(gen, scope)
+        params, inner_scope, base, safe = self._parse_comp_target(gen, scope)
+        # The loop var is safe-static (its icons are collectable) only when the
+        # iterable is a literal/prop; else it shadows any outer safe var. The
+        # iterable (base) was parsed above in the OUTER scope; the ifs and body
+        # below run with the loop var's safety in effect.
+        saved_safe = self._safe_loop_vars
+        self._safe_loop_vars = ((saved_safe | set(params)) if safe
+                                else (saved_safe - set(params)))
+        try:
+            if gen.ifs:
+                cond = self._and_conditions(gen.ifs, inner_scope)
+                base = {
+                    "expr": "method", "target": base, "name": "filter",
+                    "args": [{"expr": "lambda", "params": params, "body": cond}],
+                }
 
-        if gen.ifs:
-            cond = self._and_conditions(gen.ifs, inner_scope)
-            base = {
-                "expr": "method", "target": base, "name": "filter",
-                "args": [{"expr": "lambda", "params": params, "body": cond}],
-            }
+            if i + 1 < len(gens):
+                inner = self._build_comprehension(elt, gens, i + 1, inner_scope)
+                return {
+                    "expr": "method", "target": base, "name": "flatMap",
+                    "args": [{"expr": "lambda", "params": params, "body": inner}],
+                }
 
-        if i + 1 < len(gens):
-            inner = self._build_comprehension(elt, gens, i + 1, inner_scope)
+            # Leaf clause. Skip an identity map: [x for x in it] → it[.filter].
+            if (
+                len(params) == 1
+                and isinstance(elt, ast.Name)
+                and elt.id == params[0]
+            ):
+                return base
+            body = self._parse_expr(elt, inner_scope)
             return {
-                "expr": "method", "target": base, "name": "flatMap",
-                "args": [{"expr": "lambda", "params": params, "body": inner}],
+                "expr": "method", "target": base, "name": "map",
+                "args": [{"expr": "lambda", "params": params, "body": body}],
             }
-
-        # Leaf clause. Skip an identity map: [x for x in it] → it[.filter].
-        if (
-            len(params) == 1
-            and isinstance(elt, ast.Name)
-            and elt.id == params[0]
-        ):
-            return base
-        body = self._parse_expr(elt, inner_scope)
-        return {
-            "expr": "method", "target": base, "name": "map",
-            "args": [{"expr": "lambda", "params": params, "body": body}],
-        }
+        finally:
+            self._safe_loop_vars = saved_safe
 
     def _parse_widget_each(self, comp: ast.expr, scope: frozenset) -> WidgetIR:
         """Lower a spread widget comprehension (``*[W(x) for x in it if c]``) to
@@ -4610,9 +4643,16 @@ class ASTParser:
             raise UnsupportedSyntaxError(
                 "a widget comprehension supports a single 'for' clause"
             )
-        params, inner, iterable = self._parse_comp_target(gens[0], scope)
-        cond = self._and_conditions(gens[0].ifs, inner) if gens[0].ifs else None
-        elt = self._parse_widget(comp.elt, inner)
+        params, inner, iterable, safe = self._parse_comp_target(gens[0], scope)
+        saved_safe = self._safe_loop_vars
+        self._safe_loop_vars = ((saved_safe | set(params)) if safe
+                                else (saved_safe - set(params)))
+        try:
+            cond = (self._and_conditions(gens[0].ifs, inner)
+                    if gens[0].ifs else None)
+            elt = self._parse_widget(comp.elt, inner)
+        finally:
+            self._safe_loop_vars = saved_safe
         return WidgetIR(type="__each", props={
             "iter": iterable, "params": params, "cond": cond, "elt": elt,
         })
@@ -4646,14 +4686,16 @@ class ASTParser:
             val_name = target.elts[1].id
             iterable = self._parse_expr(it.args[0], scope)
             params = [val_name, idx_name]  # JS forEach/map order: value, index
-            return params, scope | {idx_name, val_name}, iterable
+            return (params, scope | {idx_name, val_name}, iterable,
+                    self._iterable_is_safe(it.args[0]))
 
         if not isinstance(target, ast.Name):
             raise UnsupportedSyntaxError(
                 "comprehension target must be a name, or (i, x) with enumerate()"
             )
         iterable = self._parse_expr(it, scope)
-        return [target.id], scope | {target.id}, iterable
+        return ([target.id], scope | {target.id}, iterable,
+                self._iterable_is_safe(it))
 
     def _and_conditions(self, ifs: list, scope: frozenset) -> Any:
         parsed = [self._parse_expr(c, scope) for c in ifs]
@@ -5580,12 +5622,117 @@ class ASTParser:
         props["name"] = self._icon_name(name_node, scope)
         return props
 
+    def _add_icon_literal(self, raw: str) -> None:
+        """Record a literal icon name (its base, minus any ``:weight`` suffix)
+        for the build's icon-subsetting."""
+        base = str(raw).partition(":")[0]
+        if re.fullmatch(r"[a-z0-9-]+", base):
+            self.icon_names.add(base)
+
+    def _scan_icon_literals(self, tree: ast.AST) -> None:
+        """Collect every LITERAL icon name in a source tree — ``icon="…"`` on any
+        call (so a component's icon prop, e.g. ``NavItem(icon="home")``, is
+        caught), ``Icon("…")`` / ``Icon(name="…")``, and ``"icon": "…"`` in dict
+        literals (menu items). Over-collection is harmless: a name absent from
+        icons.css is dropped when subsetting. Whether the FULL sheet is still
+        needed (a state-fed name) is decided per site in ``_icon_name``."""
+        for n in ast.walk(tree):
+            if isinstance(n, ast.Call):
+                fn = n.func
+                fname = (fn.attr if isinstance(fn, ast.Attribute)
+                         else getattr(fn, "id", ""))
+                for kw in n.keywords:
+                    if kw.arg == "icon" and _is_str_const(kw.value):
+                        self._add_icon_literal(kw.value.value)
+                    elif (kw.arg == "name" and fname == "Icon"
+                          and _is_str_const(kw.value)):
+                        self._add_icon_literal(kw.value.value)
+                if fname == "Icon" and n.args and _is_str_const(n.args[0]):
+                    self._add_icon_literal(n.args[0].value)
+            elif isinstance(n, ast.Dict):
+                for k, v in zip(n.keys, n.values):
+                    if (_is_str_const(k) and k.value == "icon"
+                            and _is_str_const(v)):
+                        self._add_icon_literal(v.value)
+            elif isinstance(n, (ast.List, ast.Tuple)):
+                # Icon-shaped string elements — e.g. NavItem's actions=["pin",
+                # "star"], iterated into per-item icons. Each literal is
+                # collected (a mixed list still contributes its literals);
+                # non-icon strings are dropped at subset time.
+                for e in n.elts:
+                    if (_is_str_const(e)
+                            and re.fullmatch(r"[a-z0-9-]+",
+                                             e.value.partition(":")[0])):
+                        self._add_icon_literal(e.value)
+            elif isinstance(n, ast.FunctionDef):
+                # A component's literal ``icon=`` default — ``def __init__(self,
+                # …, icon="circle")`` — renders when the prop is omitted, so
+                # collect it. Defaults align to the tail of the positional args;
+                # keyword-only defaults pair 1:1 (None where absent).
+                a = n.args
+                pairs = list(zip(a.args[len(a.args) - len(a.defaults):],
+                                 a.defaults))
+                pairs += list(zip(a.kwonlyargs, a.kw_defaults))
+                for param, default in pairs:
+                    if param.arg == "icon" and _is_str_const(default):
+                        self._add_icon_literal(default.value)
+
+    def _icon_expr_is_dynamic(self, node: ast.expr, scope: frozenset) -> bool:
+        """Whether a NON-literal icon name can vary at runtime, so the full icon
+        set must be kept. A component-prop reference — ``self.<prop>``, or a
+        subscript/attribute rooted at one (the SDK NavItem's ``Icon(self.icon)``
+        and ``Icon(self.item["icon"])``) — is NOT dynamic: its literal values are
+        collected from the call sites. A state read (``self.<state>``), an
+        f-string, a call or any other expression IS, so the build safely falls
+        back to the CDN full set. Component props live in ``_current_props`` (the
+        ``scope`` arg is the local/loop vars in effect)."""
+        props = self._current_props
+        n = node
+        while isinstance(n, (ast.Subscript, ast.Attribute)):
+            if (isinstance(n, ast.Attribute) and isinstance(n.value, ast.Name)
+                    and n.value.id == "self"):
+                return n.attr not in props     # a prop → static; else state
+            n = n.value
+        if isinstance(n, ast.Name):
+            # A bare local/loop variable (or its subscript/attribute) — e.g.
+            # `for a in self.actions: Icon(a)`. Static ONLY when it iterates a
+            # statically known set (a list literal, or a prop): those loop vars
+            # are in _safe_loop_vars. A loop over State (or a call) is NOT, so
+            # it's dynamic and the build keeps the full sheet.
+            return n.id not in self._safe_loop_vars
+        return True                            # f-string, call, etc. → dynamic
+
+    def _iterable_is_safe(self, node: ast.expr) -> bool:
+        """A comprehension iterable whose per-item icon names are statically
+        collectable: a list/tuple of string LITERALS (scanned), or a component
+        prop (``self.<prop>``, fed literals at the call sites). A State read, a
+        mixed list, a call (a fetch) or an unknown expression is NOT — a loop var
+        over it is runtime-dynamic, so the build falls back to the full sheet."""
+        if isinstance(node, (ast.List, ast.Tuple)):
+            return all(_is_str_const(e) for e in node.elts)
+        if (isinstance(node, ast.Attribute) and isinstance(node.value, ast.Name)
+                and node.value.id == "self"):
+            return node.attr in self._current_props
+        return False
+
+    def _note_component_icon_prop(
+        self, prop_name: str, value_node: ast.expr, scope: frozenset
+    ) -> None:
+        """A component instance's ``icon=`` prop. Literal values are already
+        collected by the scan; a NON-literal that is state-derived (not a prop
+        passthrough like ``NavItem(icon=self.icon)``) can't be known at build
+        time, so keep the full icon sheet."""
+        if (prop_name == "icon" and not _is_str_const(value_node)
+                and self._icon_expr_is_dynamic(value_node, scope)):
+            self.dynamic_icons = True
+
     def _icon_name(self, node: ast.expr, scope: frozenset) -> Any:
         """Validate a Tabler icon name (the Icon widget's name, or a Button/Link
         ``icon=``). A string literal must be ``[a-z0-9-]`` (a clear error for
         typos); a dynamic value (state / f-string → a dict expression) is allowed
         and sanitised to the same charset by the runtime, so it can only ever
-        produce a safe class."""
+        produce a safe class. Both feed the build's icon-subsetting: a literal is
+        recorded, a state-fed name keeps the full sheet (see _icon_expr_is_dynamic)."""
         name = self._parse_text_value(node, scope)
         if isinstance(name, str):
             base, sep, suffix = name.partition(":")
@@ -5602,6 +5749,10 @@ class ASTParser:
                     "with a stroke-weight suffix like 'arrow-left:2'; "
                     f"got: {name!r}"
                 )
+            self.icon_names.add(base)
+        elif isinstance(name, dict):
+            if self._icon_expr_is_dynamic(node, scope):
+                self.dynamic_icons = True
         if not isinstance(name, (str, dict)):
             raise UnsupportedSyntaxError(f"icon must be a string; got: {name!r}")
         return name

{workpeg-0.97.2 → workpeg-0.98.0}/src/workpeg/ui/compiler/js_generator.py

@@ -82,7 +82,9 @@ _LISTVIEW_PROPS = {
 class JSGenerator:
 
     #: Set True while generating if the app renders any ``Icon`` — the build
-    #: reads it to link the icon stylesheet (from the CDN) only when it's needed.
+    #: reads it to link the icon stylesheet only when it's needed. WHICH icons
+    #: (for subsetting) and whether any is dynamic are collected by the parser
+    #: (ASTParser.icon_names / .dynamic_icons), which sees component icon props.
     uses_icons = False
 
     def generate(self, ir: "AppIR | RouterIR") -> str:

{workpeg-0.97.2 → workpeg-0.98.0/src/workpeg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.97.2
+Version: 0.98.0
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.97.2 → workpeg-0.98.0}/src/workpeg.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ src/workpeg/ui/compiler/ast_parser.py
 src/workpeg/ui/compiler/ir.py
 src/workpeg/ui/compiler/js_generator.py
 src/workpeg/ui/runtime/ai.js
+src/workpeg/ui/runtime/icons.css.gz
 src/workpeg/ui/runtime/pegment.css
 src/workpeg/ui/runtime/scaffold.js
 src/workpeg/ui/runtime/workpeg-runtime.js