hypie 0.1.1.dev2__py3-none-any.whl

hypie/experimental/components.py

@@ -0,0 +1,135 @@
+from dataclasses import dataclass, is_dataclass
+from typing import dataclass_transform
+from textwrap import indent
+
+import htpy
+from markupsafe import Markup
+
+from hypie.hs_ast.helpers import kebab_case_name, htpy_to_tree, tree_to_htpy
+
+
+def transform_root(el: dict, component_name: str):
+    if not isinstance(el, dict):
+        return el
+    k, v = next(iter(el.items()))
+    if k == "_fragment":
+        return {
+            k: {
+                "children": [transform_root(c, component_name) for c in v["children"]],
+                "attrs": v["attrs"],
+            }
+        }
+    if "data-hypie-component" in v["attrs"]:
+        return el
+    return {
+        k: {
+            "children": v["children"],
+            "attrs": v["attrs"] + f' data-hypie-component="{component_name}"',
+        }
+    }
+
+
+SPACES = " " * 2
+
+
+def parse_css_dict(k, v: dict):
+    parts = [f"{k} {{"]
+    for sub_k, sub_v in v.items():
+        if sub_k.strip() == "@apply":
+            if isinstance(sub_v, list):
+                parts.append(
+                    indent(
+                        f"@apply {' '.join(sub_v)};",
+                        prefix=SPACES,
+                        predicate=lambda _: True,
+                    )
+                )
+            else:
+                parts.append(
+                    indent(f"@apply {sub_v};", prefix=SPACES, predicate=lambda _: True)
+                )
+        elif isinstance(sub_v, str):
+            parts.append(
+                indent(f"{sub_k}: {sub_v};", prefix=SPACES, predicate=lambda _: True)
+            )
+        elif isinstance(sub_v, dict):
+            parts.append(
+                indent(
+                    parse_css_dict(sub_k, sub_v),
+                    prefix=SPACES,
+                    predicate=lambda _: True,
+                )
+            )
+    parts.append("}")
+    return "\n".join(parts)
+
+
+def generate_scoped_css(component_name, css_dict):
+    css_parts = [f"@scope ({component_name}) {{"]
+    for k, v in css_dict.items():
+        css_parts.append(
+            indent(parse_css_dict(k, v), prefix=SPACES, predicate=lambda _: True)
+        )
+    css_parts.append("}")
+    return "\n\n".join(css_parts)
+
+
+class ComponentMeta(type):
+    def __getitem__(cls, children):
+        instance = Component.__new__(cls)
+        instance.children = children
+        return instance
+
+
+@dataclass_transform()
+class Component(metaclass=ComponentMeta):
+    children = None
+
+    def __new__(cls, *args, **kwargs):
+        dataclass_cls = cls
+        if not is_dataclass(cls):
+            dataclass_cls = dataclass(cls)
+        instance = object.__new__(dataclass_cls)
+        return instance
+
+    def __init_subclass__(cls, as_fragment=False, hidden=False, contents=False):
+        cls._hs_dsl_component = True
+        cls.as_fragment = as_fragment
+        cls.hidden = hidden
+        cls.contents = contents
+        cls.component_name = kebab_case_name(cls.__name__)
+        cls.tag = f"div[data-hypie-component='{cls.component_name}']"
+
+    def __html__(self):
+        el = self.template()
+        new_el = tree_to_htpy(transform_root(htpy_to_tree(el), self.component_name))
+        # print(new_el)
+        return new_el
+
+    def __getitem__(self, children):
+        if hasattr(self, "children") and self.children:
+            raise Exception("Can not reassign children twice")
+        self.children = children
+        return self
+
+    def template(self):
+        return htpy.fragment[self.children]
+
+    @staticmethod
+    def style() -> dict:
+        pass
+
+    @classmethod
+    def generate_style(cls, with_style_tags=True):
+        output_style = cls.style()
+        if output_style:
+            css = generate_scoped_css(cls.tag, cls.style())
+            if with_style_tags:
+                return htpy.style[Markup(css)]
+            return Markup(css)
+
+    def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes:
+        return str(self).encode(encoding, errors)
+
+    def __str__(self):
+        return str(self.__html__())

hypie/experimental/hyperscript.py

@@ -0,0 +1,35 @@
+import dataclasses
+
+from hypie.literals import var
+from hypie.commands import set_
+from hypie import hs
+
+
+class HyperScript:
+    def __new__(cls, *args, **kwargs):
+        raise Exception("HyperScript class is not meant to be instantiated.")
+
+    def __init_subclass__(cls):
+        if not dataclasses.is_dataclass(cls):
+            dataclasses.dataclass(cls, init=False)
+        cls._hs_dsl_hyperscript = True
+        cls._vars_script = hs()
+        for f in dataclasses.fields(cls):
+            setattr(cls, f.name, var(f"${cls.__name__}__{f.name}"))
+            cls._vars_script.add_features(
+                set_(
+                    var(f"${cls.__name__}__{f.name}"),
+                    to=f.default if f.default != dataclasses.MISSING else None,
+                )
+            )
+
+    @classmethod
+    def script(cls):
+        return hs()
+
+    @classmethod
+    def register_hyperscript(cls):
+        _hs = hs()
+        _hs.add_features(cls._vars_script)
+        _hs.add_features(cls.script())
+        return _hs

hypie/experimental/templates.py

@@ -0,0 +1,50 @@
+import dataclasses
+import htpy
+
+# from hypie.literals import var
+from hypie.hs_ast.expressions import TemplatedVariableLiteral
+from hypie.hs_ast.helpers import (
+    kebab_case_name,
+    htpy_to_tree,
+    tranform_tree,
+    tree_to_htpy,
+)
+from hypie.hs_ast.expressions import VarTemplateString
+from typing import dataclass_transform
+
+
+@dataclass_transform()
+class Template:
+    field_names = None
+
+    def __init_subclass__(cls):
+        dataclasses.dataclass(cls)
+        cls._hs_dsl_template = True
+        for f in dataclasses.fields(cls):
+            setattr(cls, f.name, TemplatedVariableLiteral(f.name))
+        setattr(cls, "field_names", [f.name for f in dataclasses.fields(cls)])
+        cls.id = kebab_case_name(cls.__name__)
+
+    # @classmethod
+    def template(cls):
+        pass
+
+    @classmethod
+    def register_template(cls):
+        template = cls(
+            **{f: TemplatedVariableLiteral(f) for f in cls.field_names}
+        ).template()
+        tree = htpy_to_tree(template)
+        transformed_tree = tranform_tree(tree, rules={"text": cls.handle_text_nodes})
+        transformed_htpy = tree_to_htpy(transformed_tree)
+        return htpy.script(type="text/hyperscript-template", id=cls.id)[
+            transformed_htpy
+        ]
+
+    @staticmethod
+    def handle_text_nodes(text):
+        # print(text)
+        exp_template = VarTemplateString(text)
+        if not exp_template.interpolations:
+            return text
+        return exp_template.transform(interp_func=lambda x: "${" + x + "}")

hypie/features.py

@@ -0,0 +1,46 @@
+from hypie.hs_ast.features import *
+from hypie.commands import set_
+from hypie.events import Event
+
+
+# so you can call it as init() or init[] both work
+Init = InitF()
+
+
+def On(*event_specs: EventSpecLiteral | str, queue: ON_QUEUE = None):
+    _event_specs = []
+    for event in event_specs:
+        if isinstance(event, type) and issubclass(event, Event):
+            _event_specs.append(
+                EventSpecLiteral(
+                    event_name=event.event_name,
+                    args=event.event_args,
+                    filter=event.event_spec and event.event_spec.filter,
+                    count=event.event_spec and event.event_spec.count,
+                    from_=event.event_spec and event.event_spec.from_,
+                    in_=event.event_spec and event.event_spec.in_,
+                    debounce=event.event_spec and event.event_spec.debounce,
+                    throttle=event.event_spec and event.event_spec.throttle,
+                )
+            )
+        else:
+            _event_specs.append(event)
+    return OnF(event_specs=_event_specs, queue=queue)
+
+
+Live = LiveF()
+
+
+def Bind(exprA: Expr, exprB: Expr, /):
+    return BindF(exprA=exprA, exprB=exprB)
+
+
+Set = set_
+
+
+def WhenChange(*exprs):
+    return WhenF(exprs=exprs)
+
+
+def Js(javascript: str, /):
+    return JsF(javascript)