Evan Almloff пре 2 година
родитељ
комит
a9b7da1890
2 измењених фајлова са 0 додато и 1956 уклоњено
  1. 0 892
      packages/rsx/src/attributes.rs
  2. 0 1064
      packages/rsx/src/template.rs

+ 0 - 892
packages/rsx/src/attributes.rs

@@ -1,892 +0,0 @@
-use crate::elements::*;
-
-// map the rsx name of the attribute to the html name of the attribute, the namespace that contains it, and if the attribute is volitile
-pub fn attrbute_to_static_str(
-    attr: &str,
-    element: &'static str,
-    namespace: Option<&'static str>,
-) -> Option<(&'static str, Option<&'static str>, bool)> {
-    if namespace == Some("http://www.w3.org/2000/svg") {
-        svg::MAPPED_ATTRIBUTES
-            .iter()
-            .find(|(a, _)| *a == attr)
-            .map(|(_, b)| (*b, None, false))
-    } else {
-        NO_NAMESPACE_ATTRIBUTES
-            .iter()
-            .find(|&a| *a == attr)
-            .map(|a| (*a, None, false))
-            .or_else(|| {
-                STYLE_ATTRIBUTES
-                    .iter()
-                    .find(|(a, _)| *a == attr)
-                    .map(|(_, b)| (*b, Some("style"), false))
-            })
-            .or_else(|| {
-                MAPPED_ATTRIBUTES
-                    .iter()
-                    .find(|(a, _)| *a == attr)
-                    .map(|(_, b)| (*b, None, false))
-            })
-    }
-    .or_else(|| {
-        ELEMENTS_WITH_MAPPED_ATTRIBUTES
-            .iter()
-            .find_map(|(el, attrs)| {
-                (element == *el)
-                    .then(|| {
-                        attrs
-                            .iter()
-                            .find(|(a, _, _)| *a == attr)
-                            .map(|(_, b, volitile)| (*b, None, *volitile))
-                    })
-                    .flatten()
-            })
-    })
-    .or_else(|| {
-        ELEMENTS_WITH_NAMESPACE.iter().find_map(|(el, ns, attrs)| {
-            (element == *el && namespace == Some(*ns))
-                .then(|| {
-                    attrs
-                        .iter()
-                        .find(|a| **a == attr)
-                        .map(|a| (*a, None, false))
-                })
-                .flatten()
-        })
-    })
-    .or_else(|| {
-        ELEMENTS_WITHOUT_NAMESPACE.iter().find_map(|(el, attrs)| {
-            (element == *el)
-                .then(|| {
-                    attrs
-                        .iter()
-                        .find(|a| **a == attr)
-                        .map(|a| (*a, None, false))
-                })
-                .flatten()
-        })
-    })
-}
-
-macro_rules! no_namespace_trait_methods {
-    (
-        $(
-            $(#[$attr:meta])*
-            $name:ident;
-        )*
-    ) => {
-        pub const NO_NAMESPACE_ATTRIBUTES: &'static [&'static str] = &[
-            $(
-                stringify!($name),
-            )*
-        ];
-    };
-}
-
-macro_rules! style_trait_methods {
-    (
-        $(
-            $(#[$attr:meta])*
-            $name:ident: $lit:literal,
-        )*
-    ) => {
-        pub const STYLE_ATTRIBUTES: &'static [(&'static str, &'static str)] = &[
-            $(
-                (stringify!($name), $lit),
-            )*
-        ];
-    };
-}
-
-macro_rules! mapped_trait_methods {
-    (
-        $(
-            $(#[$attr:meta])*
-            $name:ident: $lit:literal,
-        )*
-    ) => {
-        pub const MAPPED_ATTRIBUTES: &'static [(&'static str, &'static str)] = &[
-            $(
-                (stringify!($name), $lit),
-            )*
-            ("prevent_default", "dioxus-prevent-default"),
-        ];
-    };
-}
-
-no_namespace_trait_methods! {
-    accesskey;
-
-    /// The HTML class attribute is used to specify a class for an HTML element.
-    ///
-    /// ## Details
-    /// Multiple HTML elements can share the same class.
-    ///
-    /// The class global attribute is a space-separated list of the case-sensitive classes of the element.
-    /// Classes allow CSS and Javascript to select and access specific elements via the class selectors or
-    /// functions like the DOM method document.getElementsByClassName.
-    ///
-    /// ## Example
-    ///
-    /// ### HTML:
-    /// ```html
-    /// <p class="note editorial">Above point sounds a bit obvious. Remove/rewrite?</p>
-    /// ```
-    ///
-    /// ### CSS:
-    /// ```css
-    /// .note {
-    ///     font-style: italic;
-    ///     font-weight: bold;
-    /// }
-    ///
-    /// .editorial {
-    ///     background: rgb(255, 0, 0, .25);
-    ///     padding: 10px;
-    /// }
-    /// ```
-    class;
-    contenteditable;
-    data;
-    dir;
-    draggable;
-    hidden;
-    id;
-    lang;
-    spellcheck;
-    style;
-    tabindex;
-    title;
-    translate;
-
-    role;
-
-    /// dangerous_inner_html is Dioxus's replacement for using innerHTML in the browser DOM. In general, setting
-    /// HTML from code is risky because it’s easy to inadvertently expose your users to a cross-site scripting (XSS)
-    /// attack. So, you can set HTML directly from Dioxus, but you have to type out dangerous_inner_html to remind
-    /// yourself that it’s dangerous
-    dangerous_inner_html;
-}
-
-// This macro creates an explicit method call for each of the style attributes.
-//
-// The left token specifies the name of the attribute in the rsx! macro, and the right string literal specifies the
-// actual name of the attribute generated.
-//
-// This roughly follows the html spec
-style_trait_methods! {
-    align_content: "align-content",
-    align_items: "align-items",
-    align_self: "align-self",
-    alignment_adjust: "alignment-adjust",
-    alignment_baseline: "alignment-baseline",
-    all: "all",
-    alt: "alt",
-    animation: "animation",
-    animation_delay: "animation-delay",
-    animation_direction: "animation-direction",
-    animation_duration: "animation-duration",
-    animation_fill_mode: "animation-fill-mode",
-    animation_iteration_count: "animation-iteration-count",
-    animation_name: "animation-name",
-    animation_play_state: "animation-play-state",
-    animation_timing_function: "animation-timing-function",
-    azimuth: "azimuth",
-    backface_visibility: "backface-visibility",
-    background: "background",
-    background_attachment: "background-attachment",
-    background_clip: "background-clip",
-    background_color: "background-color",
-    background_image: "background-image",
-    background_origin: "background-origin",
-    background_position: "background-position",
-    background_repeat: "background-repeat",
-    background_size: "background-size",
-    background_blend_mode: "background-blend-mode",
-    baseline_shift: "baseline-shift",
-    bleed: "bleed",
-    bookmark_label: "bookmark-label",
-    bookmark_level: "bookmark-level",
-    bookmark_state: "bookmark-state",
-    border: "border",
-    border_color: "border-color",
-    border_style: "border-style",
-    border_width: "border-width",
-    border_bottom: "border-bottom",
-    border_bottom_color: "border-bottom-color",
-    border_bottom_style: "border-bottom-style",
-    border_bottom_width: "border-bottom-width",
-    border_left: "border-left",
-    border_left_color: "border-left-color",
-    border_left_style: "border-left-style",
-    border_left_width: "border-left-width",
-    border_right: "border-right",
-    border_right_color: "border-right-color",
-    border_right_style: "border-right-style",
-    border_right_width: "border-right-width",
-    border_top: "border-top",
-    border_top_color: "border-top-color",
-    border_top_style: "border-top-style",
-    border_top_width: "border-top-width",
-    border_collapse: "border-collapse",
-    border_image: "border-image",
-    border_image_outset: "border-image-outset",
-    border_image_repeat: "border-image-repeat",
-    border_image_slice: "border-image-slice",
-    border_image_source: "border-image-source",
-    border_image_width: "border-image-width",
-    border_radius: "border-radius",
-    border_bottom_left_radius: "border-bottom-left-radius",
-    border_bottom_right_radius: "border-bottom-right-radius",
-    border_top_left_radius: "border-top-left-radius",
-    border_top_right_radius: "border-top-right-radius",
-    border_spacing: "border-spacing",
-    bottom: "bottom",
-    box_decoration_break: "box-decoration-break",
-    box_shadow: "box-shadow",
-    box_sizing: "box-sizing",
-    box_snap: "box-snap",
-    break_after: "break-after",
-    break_before: "break-before",
-    break_inside: "break-inside",
-    buffered_rendering: "buffered-rendering",
-    caption_side: "caption-side",
-    clear: "clear",
-    clear_side: "clear-side",
-    clip: "clip",
-    clip_path: "clip-path",
-    clip_rule: "clip-rule",
-    color: "color",
-    color_adjust: "color-adjust",
-    color_correction: "color-correction",
-    color_interpolation: "color-interpolation",
-    color_interpolation_filters: "color-interpolation-filters",
-    color_profile: "color-profile",
-    color_rendering: "color-rendering",
-    column_fill: "column-fill",
-    column_gap: "column-gap",
-    column_rule: "column-rule",
-    column_rule_color: "column-rule-color",
-    column_rule_style: "column-rule-style",
-    column_rule_width: "column-rule-width",
-    column_span: "column-span",
-    columns: "columns",
-    column_count: "column-count",
-    column_width: "column-width",
-    contain: "contain",
-    content: "content",
-    counter_increment: "counter-increment",
-    counter_reset: "counter-reset",
-    counter_set: "counter-set",
-    cue: "cue",
-    cue_after: "cue-after",
-    cue_before: "cue-before",
-    cursor: "cursor",
-    direction: "direction",
-    display: "display",
-    display_inside: "display-inside",
-    display_outside: "display-outside",
-    display_extras: "display-extras",
-    display_box: "display-box",
-    dominant_baseline: "dominant-baseline",
-    elevation: "elevation",
-    empty_cells: "empty-cells",
-    enable_background: "enable-background",
-    fill: "fill",
-    fill_opacity: "fill-opacity",
-    fill_rule: "fill-rule",
-    filter: "filter",
-    float: "float",
-    float_defer_column: "float-defer-column",
-    float_defer_page: "float-defer-page",
-    float_offset: "float-offset",
-    float_wrap: "float-wrap",
-    flow_into: "flow-into",
-    flow_from: "flow-from",
-    flex: "flex",
-    flex_basis: "flex-basis",
-    flex_grow: "flex-grow",
-    flex_shrink: "flex-shrink",
-    flex_flow: "flex-flow",
-    flex_direction: "flex-direction",
-    flex_wrap: "flex-wrap",
-    flood_color: "flood-color",
-    flood_opacity: "flood-opacity",
-    font: "font",
-    font_family: "font-family",
-    font_size: "font-size",
-    font_stretch: "font-stretch",
-    font_style: "font-style",
-    font_weight: "font-weight",
-    font_feature_settings: "font-feature-settings",
-    font_kerning: "font-kerning",
-    font_language_override: "font-language-override",
-    font_size_adjust: "font-size-adjust",
-    font_synthesis: "font-synthesis",
-    font_variant: "font-variant",
-    font_variant_alternates: "font-variant-alternates",
-    font_variant_caps: "font-variant-caps",
-    font_variant_east_asian: "font-variant-east-asian",
-    font_variant_ligatures: "font-variant-ligatures",
-    font_variant_numeric: "font-variant-numeric",
-    font_variant_position: "font-variant-position",
-    footnote_policy: "footnote-policy",
-    glyph_orientation_horizontal: "glyph-orientation-horizontal",
-    glyph_orientation_vertical: "glyph-orientation-vertical",
-    grid: "grid",
-    grid_auto_flow: "grid-auto-flow",
-    grid_auto_columns: "grid-auto-columns",
-    grid_auto_rows: "grid-auto-rows",
-    grid_template: "grid-template",
-    grid_template_areas: "grid-template-areas",
-    grid_template_columns: "grid-template-columns",
-    grid_template_rows: "grid-template-rows",
-    grid_area: "grid-area",
-    grid_column: "grid-column",
-    grid_column_start: "grid-column-start",
-    grid_column_end: "grid-column-end",
-    grid_row: "grid-row",
-    grid_row_start: "grid-row-start",
-    grid_row_end: "grid-row-end",
-    hanging_punctuation: "hanging-punctuation",
-    height: "height",
-    hyphenate_character: "hyphenate-character",
-    hyphenate_limit_chars: "hyphenate-limit-chars",
-    hyphenate_limit_last: "hyphenate-limit-last",
-    hyphenate_limit_lines: "hyphenate-limit-lines",
-    hyphenate_limit_zone: "hyphenate-limit-zone",
-    hyphens: "hyphens",
-    icon: "icon",
-    image_orientation: "image-orientation",
-    image_resolution: "image-resolution",
-    image_rendering: "image-rendering",
-    ime: "ime",
-    ime_align: "ime-align",
-    ime_mode: "ime-mode",
-    ime_offset: "ime-offset",
-    ime_width: "ime-width",
-    initial_letters: "initial-letters",
-    inline_box_align: "inline-box-align",
-    isolation: "isolation",
-    justify_content: "justify-content",
-    justify_items: "justify-items",
-    justify_self: "justify-self",
-    kerning: "kerning",
-    left: "left",
-    letter_spacing: "letter-spacing",
-    lighting_color: "lighting-color",
-    line_box_contain: "line-box-contain",
-    line_break: "line-break",
-    line_grid: "line-grid",
-    line_height: "line-height",
-    line_slack: "line-slack",
-    line_snap: "line-snap",
-    list_style: "list-style",
-    list_style_image: "list-style-image",
-    list_style_position: "list-style-position",
-    list_style_type: "list-style-type",
-    margin: "margin",
-    margin_bottom: "margin-bottom",
-    margin_left: "margin-left",
-    margin_right: "margin-right",
-    margin_top: "margin-top",
-    marker: "marker",
-    marker_end: "marker-end",
-    marker_mid: "marker-mid",
-    marker_pattern: "marker-pattern",
-    marker_segment: "marker-segment",
-    marker_start: "marker-start",
-    marker_knockout_left: "marker-knockout-left",
-    marker_knockout_right: "marker-knockout-right",
-    marker_side: "marker-side",
-    marks: "marks",
-    marquee_direction: "marquee-direction",
-    marquee_play_count: "marquee-play-count",
-    marquee_speed: "marquee-speed",
-    marquee_style: "marquee-style",
-    mask: "mask",
-    mask_image: "mask-image",
-    mask_repeat: "mask-repeat",
-    mask_position: "mask-position",
-    mask_clip: "mask-clip",
-    mask_origin: "mask-origin",
-    mask_size: "mask-size",
-    mask_box: "mask-box",
-    mask_box_outset: "mask-box-outset",
-    mask_box_repeat: "mask-box-repeat",
-    mask_box_slice: "mask-box-slice",
-    mask_box_source: "mask-box-source",
-    mask_box_width: "mask-box-width",
-    mask_type: "mask-type",
-    max_height: "max-height",
-    max_lines: "max-lines",
-    max_width: "max-width",
-    min_height: "min-height",
-    min_width: "min-width",
-    mix_blend_mode: "mix-blend-mode",
-    nav_down: "nav-down",
-    nav_index: "nav-index",
-    nav_left: "nav-left",
-    nav_right: "nav-right",
-    nav_up: "nav-up",
-    object_fit: "object-fit",
-    object_position: "object-position",
-    offset_after: "offset-after",
-    offset_before: "offset-before",
-    offset_end: "offset-end",
-    offset_start: "offset-start",
-    opacity: "opacity",
-    order: "order",
-    orphans: "orphans",
-    outline: "outline",
-    outline_color: "outline-color",
-    outline_style: "outline-style",
-    outline_width: "outline-width",
-    outline_offset: "outline-offset",
-    overflow: "overflow",
-    overflow_x: "overflow-x",
-    overflow_y: "overflow-y",
-    overflow_style: "overflow-style",
-    overflow_wrap: "overflow-wrap",
-    padding: "padding",
-    padding_bottom: "padding-bottom",
-    padding_left: "padding-left",
-    padding_right: "padding-right",
-    padding_top: "padding-top",
-    page: "page",
-    page_break_after: "page-break-after",
-    page_break_before: "page-break-before",
-    page_break_inside: "page-break-inside",
-    paint_order: "paint-order",
-    pause: "pause",
-    pause_after: "pause-after",
-    pause_before: "pause-before",
-    perspective: "perspective",
-    perspective_origin: "perspective-origin",
-    pitch: "pitch",
-    pitch_range: "pitch-range",
-    play_during: "play-during",
-    pointer_events: "pointer-events",
-    position: "position",
-    quotes: "quotes",
-    region_fragment: "region-fragment",
-    resize: "resize",
-    rest: "rest",
-    rest_after: "rest-after",
-    rest_before: "rest-before",
-    richness: "richness",
-    right: "right",
-    ruby_align: "ruby-align",
-    ruby_merge: "ruby-merge",
-    ruby_position: "ruby-position",
-    scroll_behavior: "scroll-behavior",
-    scroll_snap_coordinate: "scroll-snap-coordinate",
-    scroll_snap_destination: "scroll-snap-destination",
-    scroll_snap_points_x: "scroll-snap-points-x",
-    scroll_snap_points_y: "scroll-snap-points-y",
-    scroll_snap_type: "scroll-snap-type",
-    shape_image_threshold: "shape-image-threshold",
-    shape_inside: "shape-inside",
-    shape_margin: "shape-margin",
-    shape_outside: "shape-outside",
-    shape_padding: "shape-padding",
-    shape_rendering: "shape-rendering",
-    size: "size",
-    speak: "speak",
-    speak_as: "speak-as",
-    speak_header: "speak-header",
-    speak_numeral: "speak-numeral",
-    speak_punctuation: "speak-punctuation",
-    speech_rate: "speech-rate",
-    stop_color: "stop-color",
-    stop_opacity: "stop-opacity",
-    stress: "stress",
-    string_set: "string-set",
-    stroke: "stroke",
-    stroke_dasharray: "stroke-dasharray",
-    stroke_dashoffset: "stroke-dashoffset",
-    stroke_linecap: "stroke-linecap",
-    stroke_linejoin: "stroke-linejoin",
-    stroke_miterlimit: "stroke-miterlimit",
-    stroke_opacity: "stroke-opacity",
-    stroke_width: "stroke-width",
-    tab_size: "tab-size",
-    table_layout: "table-layout",
-    text_align: "text-align",
-    text_align_all: "text-align-all",
-    text_align_last: "text-align-last",
-    text_anchor: "text-anchor",
-    text_combine_upright: "text-combine-upright",
-    text_decoration: "text-decoration",
-    text_decoration_color: "text-decoration-color",
-    text_decoration_line: "text-decoration-line",
-    text_decoration_style: "text-decoration-style",
-    text_decoration_skip: "text-decoration-skip",
-    text_emphasis: "text-emphasis",
-    text_emphasis_color: "text-emphasis-color",
-    text_emphasis_style: "text-emphasis-style",
-    text_emphasis_position: "text-emphasis-position",
-    text_emphasis_skip: "text-emphasis-skip",
-    text_height: "text-height",
-    text_indent: "text-indent",
-    text_justify: "text-justify",
-    text_orientation: "text-orientation",
-    text_overflow: "text-overflow",
-    text_rendering: "text-rendering",
-    text_shadow: "text-shadow",
-    text_size_adjust: "text-size-adjust",
-    text_space_collapse: "text-space-collapse",
-    text_spacing: "text-spacing",
-    text_transform: "text-transform",
-    text_underline_position: "text-underline-position",
-    text_wrap: "text-wrap",
-    top: "top",
-    touch_action: "touch-action",
-    transform: "transform",
-    transform_box: "transform-box",
-    transform_origin: "transform-origin",
-    transform_style: "transform-style",
-    transition: "transition",
-    transition_delay: "transition-delay",
-    transition_duration: "transition-duration",
-    transition_property: "transition-property",
-    unicode_bidi: "unicode-bidi",
-    vector_effect: "vector-effect",
-    vertical_align: "vertical-align",
-    visibility: "visibility",
-    voice_balance: "voice-balance",
-    voice_duration: "voice-duration",
-    voice_family: "voice-family",
-    voice_pitch: "voice-pitch",
-    voice_range: "voice-range",
-    voice_rate: "voice-rate",
-    voice_stress: "voice-stress",
-    voice_volumn: "voice-volumn",
-    volume: "volume",
-    white_space: "white-space",
-    widows: "widows",
-    width: "width",
-    will_change: "will-change",
-    word_break: "word-break",
-    word_spacing: "word-spacing",
-    word_wrap: "word-wrap",
-    wrap_flow: "wrap-flow",
-    wrap_through: "wrap-through",
-    writing_mode: "writing-mode",
-    gap: "gap",
-    list_styler_type: "list-style-type",
-    row_gap: "row-gap",
-    transition_timing_function: "transition-timing-function",
-    user_select: "user-select",
-    webkit_user_select: "-webkit-user-select",
-    z_index : "z-index",
-}
-mapped_trait_methods! {
-    aria_current: "aria-current",
-    aria_details: "aria-details",
-    aria_disabled: "aria-disabled",
-    aria_hidden: "aria-hidden",
-    aria_invalid: "aria-invalid",
-    aria_keyshortcuts: "aria-keyshortcuts",
-    aria_label: "aria-label",
-    aria_roledescription: "aria-roledescription",
-    // Widget Attributes
-    aria_autocomplete: "aria-autocomplete",
-    aria_checked: "aria-checked",
-    aria_expanded: "aria-expanded",
-    aria_haspopup: "aria-haspopup",
-    aria_level: "aria-level",
-    aria_modal: "aria-modal",
-    aria_multiline: "aria-multiline",
-    aria_multiselectable: "aria-multiselectable",
-    aria_orientation: "aria-orientation",
-    aria_placeholder: "aria-placeholder",
-    aria_pressed: "aria-pressed",
-    aria_readonly: "aria-readonly",
-    aria_required: "aria-required",
-    aria_selected: "aria-selected",
-    aria_sort: "aria-sort",
-    aria_valuemax: "aria-valuemax",
-    aria_valuemin: "aria-valuemin",
-    aria_valuenow: "aria-valuenow",
-    aria_valuetext: "aria-valuetext",
-    // Live Region Attributes
-    aria_atomic: "aria-atomic",
-    aria_busy: "aria-busy",
-    aria_live: "aria-live",
-    aria_relevant: "aria-relevant",
-
-    aria_dropeffect: "aria-dropeffect",
-    aria_grabbed: "aria-grabbed",
-    // Relationship Attributes
-    aria_activedescendant: "aria-activedescendant",
-    aria_colcount: "aria-colcount",
-    aria_colindex: "aria-colindex",
-    aria_colspan: "aria-colspan",
-    aria_controls: "aria-controls",
-    aria_describedby: "aria-describedby",
-    aria_errormessage: "aria-errormessage",
-    aria_flowto: "aria-flowto",
-    aria_labelledby: "aria-labelledby",
-    aria_owns: "aria-owns",
-    aria_posinset: "aria-posinset",
-    aria_rowcount: "aria-rowcount",
-    aria_rowindex: "aria-rowindex",
-    aria_rowspan: "aria-rowspan",
-    aria_setsize: "aria-setsize",
-}
-
-pub mod svg {
-    mapped_trait_methods! {
-        accent_height: "accent-height",
-        accumulate: "accumulate",
-        additive: "additive",
-        alignment_baseline: "alignment-baseline",
-        alphabetic: "alphabetic",
-        amplitude: "amplitude",
-        arabic_form: "arabic-form",
-        ascent: "ascent",
-        attributeName: "attributeName",
-        attributeType: "attributeType",
-        azimuth: "azimuth",
-        baseFrequency: "baseFrequency",
-        baseline_shift: "baseline-shift",
-        baseProfile: "baseProfile",
-        bbox: "bbox",
-        begin: "begin",
-        bias: "bias",
-        by: "by",
-        calcMode: "calcMode",
-        cap_height: "cap-height",
-        class: "class",
-        clip: "clip",
-        clipPathUnits: "clipPathUnits",
-        clip_path: "clip-path",
-        clip_rule: "clip-rule",
-        color: "color",
-        color_interpolation: "color-interpolation",
-        color_interpolation_filters: "color-interpolation-filters",
-        color_profile: "color-profile",
-        color_rendering: "color-rendering",
-        contentScriptType: "contentScriptType",
-        contentStyleType: "contentStyleType",
-        crossorigin: "crossorigin",
-        cursor: "cursor",
-        cx: "cx",
-        cy: "cy",
-        d: "d",
-        decelerate: "decelerate",
-        descent: "descent",
-        diffuseConstant: "diffuseConstant",
-        direction: "direction",
-        display: "display",
-        divisor: "divisor",
-        dominant_baseline: "dominant-baseline",
-        dur: "dur",
-        dx: "dx",
-        dy: "dy",
-        edgeMode: "edgeMode",
-        elevation: "elevation",
-        enable_background: "enable-background",
-        end: "end",
-        exponent: "exponent",
-        fill: "fill",
-        fill_opacity: "fill-opacity",
-        fill_rule: "fill-rule",
-        filter: "filter",
-        filterRes: "filterRes",
-        filterUnits: "filterUnits",
-        flood_color: "flood-color",
-        flood_opacity: "flood-opacity",
-        font_family: "font-family",
-        font_size: "font-size",
-        font_size_adjust: "font-size-adjust",
-        font_stretch: "font-stretch",
-        font_style: "font-style",
-        font_variant: "font-variant",
-        font_weight: "font-weight",
-        format: "format",
-        from: "from",
-        fr: "fr",
-        fx: "fx",
-        fy: "fy",
-        g1: "g1",
-        g2: "g2",
-        glyph_name: "glyph-name",
-        glyph_orientation_horizontal: "glyph-orientation-horizontal",
-        glyph_orientation_vertical: "glyph-orientation-vertical",
-        glyphRef: "glyphRef",
-        gradientTransform: "gradientTransform",
-        gradientUnits: "gradientUnits",
-        hanging: "hanging",
-        height: "height",
-        href: "href",
-        hreflang: "hreflang",
-        horiz_adv_x: "horiz-adv-x",
-        horiz_origin_x: "horiz-origin-x",
-        id: "id",
-        ideographic: "ideographic",
-        image_rendering: "image-rendering",
-        _in: "_in",
-        in2: "in2",
-        intercept: "intercept",
-        k: "k",
-        k1: "k1",
-        k2: "k2",
-        k3: "k3",
-        k4: "k4",
-        kernelMatrix: "kernelMatrix",
-        kernelUnitLength: "kernelUnitLength",
-        kerning: "kerning",
-        keyPoints: "keyPoints",
-        keySplines: "keySplines",
-        keyTimes: "keyTimes",
-        lang: "lang",
-        lengthAdjust: "lengthAdjust",
-        letter_spacing: "letter-spacing",
-        lighting_color: "lighting-color",
-        limitingConeAngle: "limitingConeAngle",
-        local: "local",
-        marker_end: "marker-end",
-        marker_mid: "marker-mid",
-        marker_start: "marker_start",
-        markerHeight: "markerHeight",
-        markerUnits: "markerUnits",
-        markerWidth: "markerWidth",
-        mask: "mask",
-        maskContentUnits: "maskContentUnits",
-        maskUnits: "maskUnits",
-        mathematical: "mathematical",
-        max: "max",
-        media: "media",
-        method: "method",
-        min: "min",
-        mode: "mode",
-        name: "name",
-        numOctaves: "numOctaves",
-        offset: "offset",
-        opacity: "opacity",
-        operator: "operator",
-        order: "order",
-        orient: "orient",
-        orientation: "orientation",
-        origin: "origin",
-        overflow: "overflow",
-        overline_position: "overline-position",
-        overline_thickness: "overline-thickness",
-        panose_1: "panose-1",
-        paint_order: "paint-order",
-        path: "path",
-        pathLength: "pathLength",
-        patternContentUnits: "patternContentUnits",
-        patternTransform: "patternTransform",
-        patternUnits: "patternUnits",
-        ping: "ping",
-        pointer_events: "pointer-events",
-        points: "points",
-        pointsAtX: "pointsAtX",
-        pointsAtY: "pointsAtY",
-        pointsAtZ: "pointsAtZ",
-        preserveAlpha: "preserveAlpha",
-        preserveAspectRatio: "preserveAspectRatio",
-        primitiveUnits: "primitiveUnits",
-        r: "r",
-        radius: "radius",
-        referrerPolicy: "referrerPolicy",
-        refX: "refX",
-        refY: "refY",
-        rel: "rel",
-        rendering_intent: "rendering-intent",
-        repeatCount: "repeatCount",
-        repeatDur: "repeatDur",
-        requiredExtensions: "requiredExtensions",
-        requiredFeatures: "requiredFeatures",
-        restart: "restart",
-        result: "result",
-        role: "role",
-        rotate: "rotate",
-        rx: "rx",
-        ry: "ry",
-        scale: "scale",
-        seed: "seed",
-        shape_rendering: "shape-rendering",
-        slope: "slope",
-        spacing: "spacing",
-        specularConstant: "specularConstant",
-        specularExponent: "specularExponent",
-        speed: "speed",
-        spreadMethod: "spreadMethod",
-        startOffset: "startOffset",
-        stdDeviation: "stdDeviation",
-        stemh: "stemh",
-        stemv: "stemv",
-        stitchTiles: "stitchTiles",
-        stop_color: "stop_color",
-        stop_opacity: "stop_opacity",
-        strikethrough_position: "strikethrough-position",
-        strikethrough_thickness: "strikethrough-thickness",
-        string: "string",
-        stroke: "stroke",
-        stroke_dasharray: "stroke-dasharray",
-        stroke_dashoffset: "stroke-dashoffset",
-        stroke_linecap: "stroke-linecap",
-        stroke_linejoin: "stroke-linejoin",
-        stroke_miterlimit: "stroke-miterlimit",
-        stroke_opacity: "stroke-opacity",
-        stroke_width: "stroke-width",
-        style: "style",
-        surfaceScale: "surfaceScale",
-        systemLanguage: "systemLanguage",
-        tabindex: "tabindex",
-        tableValues: "tableValues",
-        target: "target",
-        targetX: "targetX",
-        targetY: "targetY",
-        text_anchor: "text-anchor",
-        text_decoration: "text-decoration",
-        text_rendering: "text-rendering",
-        textLength: "textLength",
-        to: "to",
-        transform: "transform",
-        transform_origin: "transform-origin",
-        r#type: "_type",
-        u1: "u1",
-        u2: "u2",
-        underline_position: "underline-position",
-        underline_thickness: "underline-thickness",
-        unicode: "unicode",
-        unicode_bidi: "unicode-bidi",
-        unicode_range: "unicode-range",
-        units_per_em: "units-per-em",
-        v_alphabetic: "v-alphabetic",
-        v_hanging: "v-hanging",
-        v_ideographic: "v-ideographic",
-        v_mathematical: "v-mathematical",
-        values: "values",
-        vector_effect: "vector-effect",
-        version: "version",
-        vert_adv_y: "vert-adv-y",
-        vert_origin_x: "vert-origin-x",
-        vert_origin_y: "vert-origin-y",
-        view_box: "viewBox",
-        view_target: "viewTarget",
-        visibility: "visibility",
-        width: "width",
-        widths: "widths",
-        word_spacing: "word-spacing",
-        writing_mode: "writing-mode",
-        x: "x",
-        x_height: "x-height",
-        x1: "x1",
-        x2: "x2",
-        xmlns: "xmlns",
-        x_channel_selector: "xChannelSelector",
-        y: "y",
-        y1: "y1",
-        y2: "y2",
-        y_channel_selector: "yChannelSelector",
-        z: "z",
-        zoomAndPan: "zoomAndPan",
-    }
-}

+ 0 - 1064
packages/rsx/src/template.rs

@@ -1,1064 +0,0 @@
-// use proc_macro2::TokenStream;
-// use quote::TokenStreamExt;
-// use quote::{quote, ToTokens};
-// use syn::{Expr, Ident, LitStr};
-
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
-// pub fn try_parse_template(
-//     rsx: &str,
-//     location: OwnedCodeLocation,
-//     previous_template: Option<DynamicTemplateContextBuilder>,
-// ) -> Result<(OwnedTemplate, DynamicTemplateContextBuilder), Error> {
-//     use crate::CallBody;
-
-//     let call_body: CallBody =
-//         syn::parse_str(rsx).map_err(|e| Error::ParseError(ParseError::new(e, location.clone())))?;
-//     let mut template_builder = TemplateBuilder::from_roots_always(call_body.roots);
-//     if let Some(prev) = previous_template {
-//         template_builder = template_builder
-//             .try_switch_dynamic_context(prev)
-//             .ok_or_else(|| {
-//                 Error::RecompileRequiredError(RecompileReason::Variable(
-//                     "dynamic context updated".to_string(),
-//                 ))
-//             })?;
-//     }
-//     let dyn_ctx = template_builder.dynamic_context.clone();
-//     Ok((template_builder.try_into_owned(&location)?, dyn_ctx))
-// }
-
-// use crate::{BodyNode, ElementAttr, FormattedSegment, Segment};
-
-// struct TemplateElementBuilder {
-//     tag: Ident,
-//     attributes: Vec<TemplateAttributeBuilder>,
-//     children: Vec<TemplateNodeId>,
-//     listeners: Vec<usize>,
-//     locally_static: bool,
-// }
-
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
-// type OwndedTemplateElement = TemplateElement<
-//     Vec<TemplateAttribute<OwnedAttributeValue>>,
-//     OwnedAttributeValue,
-//     Vec<TemplateNodeId>,
-//     Vec<usize>,
-// >;
-
-// impl TemplateElementBuilder {
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwndedTemplateElement, Error> {
-//         let Self {
-//             tag,
-//             attributes,
-//             children,
-//             listeners,
-//             ..
-//         } = self;
-//         let (element_tag, element_ns) =
-//             element_to_static_str(&tag.to_string()).ok_or_else(|| {
-//                 Error::ParseError(ParseError::new(
-//                     syn::Error::new(tag.span(), format!("unknown element: {}", tag)),
-//                     location.clone(),
-//                 ))
-//             })?;
-
-//         let mut owned_attributes = Vec::new();
-//         for a in attributes {
-//             owned_attributes.push(a.try_into_owned(location, element_tag, element_ns)?);
-//         }
-
-//         Ok(TemplateElement::new(
-//             element_tag,
-//             element_ns,
-//             owned_attributes,
-//             children,
-//             listeners,
-//         ))
-//     }
-// }
-
-// impl ToTokens for TemplateElementBuilder {
-//     fn to_tokens(&self, tokens: &mut TokenStream) {
-//         let Self {
-//             tag,
-//             attributes,
-//             children,
-//             listeners,
-//             ..
-//         } = self;
-//         let children = children.iter().map(|id| {
-//             let raw = id.0;
-//             quote! {TemplateNodeId(#raw)}
-//         });
-//         tokens.append_all(quote! {
-//             TemplateElement::new(
-//                 dioxus_elements::#tag::TAG_NAME,
-//                 dioxus_elements::#tag::NAME_SPACE,
-//                 &[#(#attributes),*],
-//                 &[#(#children),*],
-//                 &[#(#listeners),*],
-//             )
-//         })
-//     }
-// }
-
-// enum AttributeName {
-//     Ident(Ident),
-//     Str(LitStr),
-// }
-
-// struct TemplateAttributeBuilder {
-//     element_tag: Ident,
-//     name: AttributeName,
-//     value: TemplateAttributeValue<OwnedAttributeValue>,
-// }
-
-// impl TemplateAttributeBuilder {
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     fn try_into_owned(
-//         self,
-//         location: &OwnedCodeLocation,
-//         element_tag: &'static str,
-//         element_ns: Option<&'static str>,
-//     ) -> Result<TemplateAttribute<OwnedAttributeValue>, Error> {
-//         let Self { name, value, .. } = self;
-//         let (name, span, literal) = match name {
-//             AttributeName::Ident(name) => (name.to_string(), name.span(), false),
-//             AttributeName::Str(name) => (name.value(), name.span(), true),
-//         };
-//         let (name, namespace, volatile) = attrbute_to_static_str(&name, element_tag, element_ns)
-//             .ok_or_else(|| {
-//                 if literal {
-//                     // literals will be captured when a full recompile is triggered
-//                     Error::RecompileRequiredError(RecompileReason::Attribute(name.to_string()))
-//                 } else {
-//                     Error::ParseError(ParseError::new(
-//                         syn::Error::new(span, format!("unknown attribute: {}", name)),
-//                         location.clone(),
-//                     ))
-//                 }
-//             })?;
-//         let attribute = AttributeDiscription {
-//             name,
-//             namespace,
-//             volatile,
-//         };
-//         Ok(TemplateAttribute { value, attribute })
-//     }
-// }
-
-// impl ToTokens for TemplateAttributeBuilder {
-//     fn to_tokens(&self, tokens: &mut TokenStream) {
-//         let Self {
-//             element_tag,
-//             name,
-//             value,
-//         } = self;
-//         let value = match value {
-//             TemplateAttributeValue::Static(val) => {
-//                 let val = match val {
-//                     OwnedAttributeValue::Text(txt) => quote! {StaticAttributeValue::Text(#txt)},
-//                     OwnedAttributeValue::Float32(f) => quote! {StaticAttributeValue::Float32(#f)},
-//                     OwnedAttributeValue::Float64(f) => quote! {StaticAttributeValue::Float64(#f)},
-//                     OwnedAttributeValue::Int32(i) => quote! {StaticAttributeValue::Int32(#i)},
-//                     OwnedAttributeValue::Int64(i) => quote! {StaticAttributeValue::Int64(#i)},
-//                     OwnedAttributeValue::Uint32(u) => quote! {StaticAttributeValue::Uint32(#u)},
-//                     OwnedAttributeValue::Uint64(u) => quote! {StaticAttributeValue::Uint64(#u)},
-//                     OwnedAttributeValue::Bool(b) => quote! {StaticAttributeValue::Bool(#b)},
-//                     OwnedAttributeValue::Vec3Float(f1, f2, f3) => {
-//                         quote! {StaticAttributeValue::Vec3Float(#f1, #f2, #f3)}
-//                     }
-//                     OwnedAttributeValue::Vec3Int(f1, f2, f3) => {
-//                         quote! {StaticAttributeValue::Vec3Int(#f1, #f2, #f3)}
-//                     }
-//                     OwnedAttributeValue::Vec3Uint(f1, f2, f3) => {
-//                         quote! {StaticAttributeValue::Vec3Uint(#f1, #f2, #f3)}
-//                     }
-//                     OwnedAttributeValue::Vec4Float(f1, f2, f3, f4) => {
-//                         quote! {StaticAttributeValue::Vec4Float(#f1, #f2, #f3, #f4)}
-//                     }
-//                     OwnedAttributeValue::Vec4Int(f1, f2, f3, f4) => {
-//                         quote! {StaticAttributeValue::Vec4Int(#f1, #f2, #f3, #f4)}
-//                     }
-//                     OwnedAttributeValue::Vec4Uint(f1, f2, f3, f4) => {
-//                         quote! {StaticAttributeValue::Vec4Uint(#f1, #f2, #f3, #f4)}
-//                     }
-//                     OwnedAttributeValue::Bytes(b) => {
-//                         quote! {StaticAttributeValue::Bytes(&[#(#b),*])}
-//                     }
-//                     OwnedAttributeValue::Any(_) => todo!(),
-//                 };
-//                 quote! {TemplateAttributeValue::Static(#val)}
-//             }
-//             TemplateAttributeValue::Dynamic(idx) => quote! {TemplateAttributeValue::Dynamic(#idx)},
-//         };
-//         match name {
-//             AttributeName::Ident(name) => tokens.append_all(quote! {
-//                 TemplateAttribute{
-//                     attribute: dioxus_elements::#element_tag::#name,
-//                     value: #value,
-//                 }
-//             }),
-//             AttributeName::Str(lit) => tokens.append_all(quote! {
-//                 TemplateAttribute{
-//                     attribute: dioxus::prelude::AttributeDiscription{
-//                         name: #lit,
-//                         namespace: None,
-//                         volatile: false
-//                     },
-//                     value: #value,
-//                 }
-//             }),
-//         }
-//     }
-// }
-
-// enum TemplateNodeTypeBuilder {
-//     Element(TemplateElementBuilder),
-//     Text(TextTemplate<Vec<TextTemplateSegment<String>>, String>),
-//     DynamicNode(usize),
-// }
-
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
-// type OwnedTemplateNodeType = TemplateNodeType<
-//     Vec<TemplateAttribute<OwnedAttributeValue>>,
-//     OwnedAttributeValue,
-//     Vec<TemplateNodeId>,
-//     Vec<usize>,
-//     Vec<TextTemplateSegment<String>>,
-//     String,
-// >;
-
-// impl TemplateNodeTypeBuilder {
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwnedTemplateNodeType, Error> {
-//         match self {
-//             TemplateNodeTypeBuilder::Element(el) => {
-//                 Ok(TemplateNodeType::Element(el.try_into_owned(location)?))
-//             }
-//             TemplateNodeTypeBuilder::Text(txt) => Ok(TemplateNodeType::Text(txt)),
-//             TemplateNodeTypeBuilder::DynamicNode(idx) => Ok(TemplateNodeType::DynamicNode(idx)),
-//         }
-//     }
-// }
-
-// impl ToTokens for TemplateNodeTypeBuilder {
-//     fn to_tokens(&self, tokens: &mut TokenStream) {
-//         match self {
-//             TemplateNodeTypeBuilder::Element(el) => tokens.append_all(quote! {
-//                 TemplateNodeType::Element(#el)
-//             }),
-//             TemplateNodeTypeBuilder::Text(txt) => {
-//                 let mut length = 0;
-
-//                 let segments = txt.segments.iter().map(|seg| match seg {
-//                     TextTemplateSegment::Static(s) => {
-//                         length += s.len();
-//                         quote!(TextTemplateSegment::Static(#s))
-//                     }
-//                     TextTemplateSegment::Dynamic(idx) => quote!(TextTemplateSegment::Dynamic(#idx)),
-//                 });
-
-//                 tokens.append_all(quote! {
-//                     TemplateNodeType::Text(TextTemplate::new(&[#(#segments),*], #length))
-//                 });
-//             }
-//             TemplateNodeTypeBuilder::DynamicNode(idx) => tokens.append_all(quote! {
-//                 TemplateNodeType::DynamicNode(#idx)
-//             }),
-//         }
-//     }
-// }
-
-// struct TemplateNodeBuilder {
-//     id: TemplateNodeId,
-//     depth: usize,
-//     parent: Option<TemplateNodeId>,
-//     node_type: TemplateNodeTypeBuilder,
-//     fully_static: bool,
-// }
-
-// impl TemplateNodeBuilder {
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwnedTemplateNode, Error> {
-//         let TemplateNodeBuilder {
-//             id,
-//             node_type,
-//             parent,
-//             depth,
-//             ..
-//         } = self;
-//         let node_type = node_type.try_into_owned(location)?;
-//         Ok(OwnedTemplateNode {
-//             id,
-//             node_type,
-//             parent,
-//             depth,
-//         })
-//     }
-
-//     fn to_tokens(&self, tokens: &mut TokenStream) {
-//         let Self {
-//             id,
-//             node_type,
-//             parent,
-//             depth,
-//             ..
-//         } = self;
-//         let raw_id = id.0;
-//         let parent = match parent {
-//             Some(id) => {
-//                 let id = id.0;
-//                 quote! {Some(TemplateNodeId(#id))}
-//             }
-//             None => quote! {None},
-//         };
-
-//         tokens.append_all(quote! {
-//             TemplateNode {
-//                 id: TemplateNodeId(#raw_id),
-//                 node_type: #node_type,
-//                 parent: #parent,
-//                 depth: #depth,
-//             }
-//         })
-//     }
-// }
-
-// #[derive(Default)]
-// pub struct TemplateBuilder {
-//     nodes: Vec<TemplateNodeBuilder>,
-//     root_nodes: Vec<TemplateNodeId>,
-//     dynamic_context: DynamicTemplateContextBuilder,
-// }
-
-// impl TemplateBuilder {
-//     /// Create a template builder from nodes if it would improve performance to do so.
-//     pub fn from_roots(roots: Vec<BodyNode>) -> Option<Self> {
-//         let mut builder = Self::default();
-
-//         for (i, root) in roots.into_iter().enumerate() {
-//             let id = builder.build_node(root, None, vec![i], 0);
-//             builder.root_nodes.push(id);
-//         }
-
-//         // only build a template if there is at least one static node
-//         if builder
-//             .nodes
-//             .iter()
-//             .all(|r| matches!(&r.node_type, TemplateNodeTypeBuilder::DynamicNode(_)))
-//         {
-//             None
-//         } else {
-//             Some(builder)
-//         }
-//     }
-
-//     /// Create a template builder from nodes regardless of performance.
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     fn from_roots_always(roots: Vec<BodyNode>) -> Self {
-//         let mut builder = Self::default();
-
-//         for (i, root) in roots.into_iter().enumerate() {
-//             let id = builder.build_node(root, None, vec![i], 0);
-//             builder.root_nodes.push(id);
-//         }
-
-//         builder
-//     }
-
-//     fn build_node(
-//         &mut self,
-//         node: BodyNode,
-//         parent: Option<TemplateNodeId>,
-//         path: Vec<usize>,
-//         depth: usize,
-//     ) -> TemplateNodeId {
-//         let id = TemplateNodeId(self.nodes.len());
-//         match node {
-//             BodyNode::Element(el) => {
-//                 let mut locally_static = true;
-//                 let mut attributes = Vec::new();
-//                 let mut listeners = Vec::new();
-//                 for attr in el.attributes {
-//                     match attr.attr {
-//                         ElementAttr::AttrText { name, value } => {
-//                             if let Some(static_value) = value.to_static() {
-//                                 attributes.push(TemplateAttributeBuilder {
-//                                     element_tag: el.name.clone(),
-//                                     name: AttributeName::Ident(name),
-//                                     value: TemplateAttributeValue::Static(
-//                                         OwnedAttributeValue::Text(static_value),
-//                                     ),
-//                                 })
-//                             } else {
-//                                 locally_static = false;
-//                                 attributes.push(TemplateAttributeBuilder {
-//                                     element_tag: el.name.clone(),
-//                                     name: AttributeName::Ident(name),
-//                                     value: TemplateAttributeValue::Dynamic(
-//                                         self.dynamic_context.add_attr(quote!(#value)),
-//                                     ),
-//                                 })
-//                             }
-//                         }
-//                         ElementAttr::CustomAttrText { name, value } => {
-//                             if let Some(static_value) = value.to_static() {
-//                                 attributes.push(TemplateAttributeBuilder {
-//                                     element_tag: el.name.clone(),
-//                                     name: AttributeName::Str(name),
-//                                     value: TemplateAttributeValue::Static(
-//                                         OwnedAttributeValue::Text(static_value),
-//                                     ),
-//                                 })
-//                             } else {
-//                                 locally_static = false;
-//                                 attributes.push(TemplateAttributeBuilder {
-//                                     element_tag: el.name.clone(),
-//                                     name: AttributeName::Str(name),
-//                                     value: TemplateAttributeValue::Dynamic(
-//                                         self.dynamic_context.add_attr(quote!(#value)),
-//                                     ),
-//                                 })
-//                             }
-//                         }
-//                         ElementAttr::AttrExpression { name, value } => {
-//                             locally_static = false;
-//                             attributes.push(TemplateAttributeBuilder {
-//                                 element_tag: el.name.clone(),
-//                                 name: AttributeName::Ident(name),
-//                                 value: TemplateAttributeValue::Dynamic(
-//                                     self.dynamic_context.add_attr(quote!(#value)),
-//                                 ),
-//                             })
-//                         }
-//                         ElementAttr::CustomAttrExpression { name, value } => {
-//                             locally_static = false;
-//                             attributes.push(TemplateAttributeBuilder {
-//                                 element_tag: el.name.clone(),
-//                                 name: AttributeName::Str(name),
-//                                 value: TemplateAttributeValue::Dynamic(
-//                                     self.dynamic_context.add_attr(quote!(#value)),
-//                                 ),
-//                             })
-//                         }
-//                         ElementAttr::EventTokens { name, tokens } => {
-//                             locally_static = false;
-//                             listeners.push(self.dynamic_context.add_listener(name, tokens))
-//                         }
-//                     }
-//                 }
-//                 if let Some(key) = el.key {
-//                     self.dynamic_context.add_key(quote!(
-//                         dioxus::core::exports::bumpalo::format!(in __bump, "{}", #key)
-//                             .into_bump_str()
-//                     ));
-//                 }
-//                 self.nodes.push(TemplateNodeBuilder {
-//                     id,
-//                     node_type: TemplateNodeTypeBuilder::Element(TemplateElementBuilder {
-//                         tag: el.name,
-//                         attributes,
-//                         children: Vec::new(),
-//                         listeners,
-//                         locally_static,
-//                     }),
-//                     parent,
-//                     depth,
-//                     fully_static: false,
-//                 });
-//                 let children: Vec<_> = el
-//                     .children
-//                     .into_iter()
-//                     .enumerate()
-//                     .map(|(i, child)| {
-//                         let mut new_path = path.clone();
-//                         new_path.push(i);
-//                         self.build_node(child, Some(id), new_path, depth + 1)
-//                     })
-//                     .collect();
-//                 let children_fully_static = children.iter().all(|c| self.nodes[c.0].fully_static);
-//                 let parent = &mut self.nodes[id.0];
-//                 parent.fully_static = locally_static && children_fully_static;
-//                 if let TemplateNodeTypeBuilder::Element(element) = &mut parent.node_type {
-//                     element.children = children;
-//                 }
-//             }
-
-//             BodyNode::Component(comp) => {
-//                 self.nodes.push(TemplateNodeBuilder {
-//                     id,
-//                     node_type: TemplateNodeTypeBuilder::DynamicNode(
-//                         self.dynamic_context.add_node(BodyNode::Component(comp)),
-//                     ),
-//                     parent,
-//                     depth,
-//                     fully_static: false,
-//                 });
-//             }
-
-//             BodyNode::Text(txt) => {
-//                 let mut segments = Vec::new();
-//                 let mut length = 0;
-//                 let mut fully_static = true;
-
-//                 for segment in txt.segments {
-//                     segments.push(match segment {
-//                         Segment::Literal(lit) => {
-//                             length += lit.len();
-//                             TextTemplateSegment::Static(lit)
-//                         }
-//                         Segment::Formatted(fmted) => {
-//                             fully_static = false;
-//                             TextTemplateSegment::Dynamic(self.dynamic_context.add_text(fmted))
-//                         }
-//                     })
-//                 }
-
-//                 self.nodes.push(TemplateNodeBuilder {
-//                     id,
-//                     node_type: TemplateNodeTypeBuilder::Text(TextTemplate::new(segments, length)),
-//                     parent,
-//                     depth,
-//                     fully_static,
-//                 });
-//             }
-
-//             BodyNode::RawExpr(expr) => {
-//                 self.nodes.push(TemplateNodeBuilder {
-//                     id,
-//                     node_type: TemplateNodeTypeBuilder::DynamicNode(
-//                         self.dynamic_context.add_node(BodyNode::RawExpr(expr)),
-//                     ),
-//                     parent,
-//                     depth,
-//                     fully_static: false,
-//                 });
-//             }
-//         }
-//         id
-//     }
-
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     pub fn try_switch_dynamic_context(
-//         mut self,
-//         dynamic_context: DynamicTemplateContextBuilder,
-//     ) -> Option<Self> {
-//         let attribute_mapping: HashMap<String, usize> = dynamic_context
-//             .attributes
-//             .iter()
-//             .enumerate()
-//             .map(|(i, ts)| (ts.to_string(), i))
-//             .collect();
-//         let text_mapping: HashMap<String, usize> = dynamic_context
-//             .text
-//             .iter()
-//             .enumerate()
-//             .map(|(i, ts)| (ts.to_token_stream().to_string(), i))
-//             .collect();
-//         let listener_mapping: HashMap<(String, Expr), usize> = dynamic_context
-//             .listeners
-//             .iter()
-//             .enumerate()
-//             .map(|(i, ts)| (ts.clone(), i))
-//             .collect();
-//         let node_mapping: HashMap<String, usize> = dynamic_context
-//             .nodes
-//             .iter()
-//             .enumerate()
-//             .map(|(i, ts)| (ts.to_token_stream().to_string(), i))
-//             .collect();
-
-//         for node in &mut self.nodes {
-//             match &mut node.node_type {
-//                 TemplateNodeTypeBuilder::Element(element) => {
-//                     for listener in &mut element.listeners {
-//                         *listener =
-//                             *listener_mapping.get(&self.dynamic_context.listeners[*listener])?;
-//                     }
-//                     for attribute in &mut element.attributes {
-//                         if let TemplateAttributeValue::Dynamic(idx) = &mut attribute.value {
-//                             *idx = *attribute_mapping
-//                                 .get(&self.dynamic_context.attributes[*idx].to_string())?;
-//                         }
-//                     }
-//                 }
-//                 TemplateNodeTypeBuilder::Text(txt) => {
-//                     for seg in &mut txt.segments {
-//                         if let TextTemplateSegment::Dynamic(idx) = seg {
-//                             *idx = *text_mapping.get(
-//                                 &self.dynamic_context.text[*idx]
-//                                     .to_token_stream()
-//                                     .to_string(),
-//                             )?;
-//                         }
-//                     }
-//                 }
-//                 TemplateNodeTypeBuilder::DynamicNode(idx) => {
-//                     *idx = *node_mapping.get(
-//                         &self.dynamic_context.nodes[*idx]
-//                             .to_token_stream()
-//                             .to_string(),
-//                     )?;
-//                 }
-//             }
-//         }
-//         self.dynamic_context = dynamic_context;
-
-//         Some(self)
-//     }
-
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     pub fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwnedTemplate, Error> {
-//         let mut nodes = Vec::new();
-//         let dynamic_mapping = self.dynamic_mapping(&nodes);
-//         let dynamic_path = self.dynamic_path();
-//         for node in self.nodes {
-//             nodes.push(node.try_into_owned(location)?);
-//         }
-
-//         Ok(OwnedTemplate {
-//             nodes,
-//             root_nodes: self.root_nodes,
-//             dynamic_mapping,
-//             dynamic_path,
-//         })
-//     }
-
-//     #[cfg(any(feature = "hot-reload", debug_assertions))]
-//     pub fn dynamic_mapping(
-//         &self,
-//         resolved_nodes: &Vec<OwnedTemplateNode>,
-//     ) -> OwnedDynamicNodeMapping {
-//         let dynamic_context = &self.dynamic_context;
-//         let mut node_mapping = vec![None; dynamic_context.nodes.len()];
-//         let nodes = &self.nodes;
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::DynamicNode(idx) = &n.node_type {
-//                 node_mapping[*idx] = Some(n.id)
-//             }
-//         }
-//         let mut text_mapping = vec![Vec::new(); dynamic_context.text.len()];
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::Text(txt) = &n.node_type {
-//                 for seg in &txt.segments {
-//                     match seg {
-//                         TextTemplateSegment::Static(_) => (),
-//                         TextTemplateSegment::Dynamic(idx) => text_mapping[*idx].push(n.id),
-//                     }
-//                 }
-//             }
-//         }
-//         let mut attribute_mapping = vec![Vec::new(); dynamic_context.attributes.len()];
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
-//                 for (i, attr) in el.attributes.iter().enumerate() {
-//                     match attr.value {
-//                         TemplateAttributeValue::Static(_) => (),
-//                         TemplateAttributeValue::Dynamic(idx) => {
-//                             attribute_mapping[idx].push((n.id, i));
-//                         }
-//                     }
-//                 }
-//             }
-//         }
-//         let mut listener_mapping = Vec::new();
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
-//                 if !el.listeners.is_empty() {
-//                     listener_mapping.push(n.id);
-//                 }
-//             }
-//         }
-
-//         let mut volatile_mapping = Vec::new();
-//         for n in resolved_nodes {
-//             if let TemplateNodeType::Element(el) = &n.node_type {
-//                 for (i, attr) in el.attributes.iter().enumerate() {
-//                     if attr.attribute.volatile {
-//                         volatile_mapping.push((n.id, i));
-//                     }
-//                 }
-//             }
-//         }
-
-//         OwnedDynamicNodeMapping::new(
-//             node_mapping,
-//             text_mapping,
-//             attribute_mapping,
-//             volatile_mapping,
-//             listener_mapping,
-//         )
-//     }
-
-//     fn dynamic_path(&self) -> Option<OwnedPathSeg> {
-//         let mut last_seg: Option<OwnedPathSeg> = None;
-//         let mut nodes_to_insert_after = Vec::new();
-//         // iterating from the last root to the first
-//         for root in self.root_nodes.iter().rev() {
-//             let root_node = &self.nodes[root.0];
-//             if let TemplateNodeTypeBuilder::DynamicNode(_) = root_node.node_type {
-//                 match &mut last_seg {
-//                     // if there has been no static nodes, we can append the child to the parent node
-//                     None => nodes_to_insert_after.push(*root),
-//                     // otherwise we insert the child before the last static node
-//                     Some(seg) => {
-//                         seg.ops.push(UpdateOp::InsertBefore(*root));
-//                     }
-//                 }
-//             } else if let Some(mut new) = self.construct_path_segment(*root) {
-//                 if let Some(last) = last_seg.take() {
-//                     match new.traverse {
-//                         OwnedTraverse::Halt => {
-//                             new.traverse = OwnedTraverse::NextSibling(Box::new(last));
-//                         }
-//                         OwnedTraverse::FirstChild(b) => {
-//                             new.traverse = OwnedTraverse::Both(Box::new((*b, last)));
-//                         }
-//                         _ => unreachable!(),
-//                     }
-//                 } else {
-//                     for node in nodes_to_insert_after.drain(..) {
-//                         new.ops.push(UpdateOp::InsertAfter(node));
-//                     }
-//                 }
-//                 last_seg = Some(new);
-//             } else if let Some(last) = last_seg.take() {
-//                 last_seg = Some(OwnedPathSeg {
-//                     ops: Vec::new(),
-//                     traverse: OwnedTraverse::NextSibling(Box::new(last)),
-//                 });
-//             }
-//         }
-//         last_seg
-//     }
-
-//     fn construct_path_segment(&self, node_id: TemplateNodeId) -> Option<OwnedPathSeg> {
-//         let n = &self.nodes[node_id.0];
-//         if n.fully_static {
-//             return None;
-//         }
-//         match &n.node_type {
-//             TemplateNodeTypeBuilder::Element(el) => {
-//                 let mut last_seg: Option<OwnedPathSeg> = None;
-//                 let mut children_to_append = Vec::new();
-//                 // iterating from the last child to the first
-//                 for child in el.children.iter().rev() {
-//                     let child_node = &self.nodes[child.0];
-//                     if let TemplateNodeTypeBuilder::DynamicNode(_) = child_node.node_type {
-//                         match &mut last_seg {
-//                             // if there has been no static nodes, we can append the child to the parent node
-//                             None => children_to_append.push(*child),
-//                             // otherwise we insert the child before the last static node
-//                             Some(seg) => {
-//                                 seg.ops.push(UpdateOp::InsertBefore(*child));
-//                             }
-//                         }
-//                     } else if let Some(mut new) = self.construct_path_segment(*child) {
-//                         if let Some(last) = last_seg.take() {
-//                             match new.traverse {
-//                                 OwnedTraverse::Halt => {
-//                                     new.traverse = OwnedTraverse::NextSibling(Box::new(last));
-//                                 }
-//                                 OwnedTraverse::FirstChild(b) => {
-//                                     new.traverse = OwnedTraverse::Both(Box::new((*b, last)));
-//                                 }
-//                                 _ => unreachable!(),
-//                             }
-//                         }
-//                         last_seg = Some(new);
-//                     } else if let Some(last) = last_seg.take() {
-//                         last_seg = Some(OwnedPathSeg {
-//                             ops: Vec::new(),
-//                             traverse: OwnedTraverse::NextSibling(Box::new(last)),
-//                         });
-//                     }
-//                 }
-//                 let mut ops = Vec::new();
-//                 if !el.locally_static || n.parent.is_none() {
-//                     ops.push(UpdateOp::StoreNode(node_id));
-//                 }
-//                 for child in children_to_append.into_iter().rev() {
-//                     ops.push(UpdateOp::AppendChild(child));
-//                 }
-//                 Some(OwnedPathSeg {
-//                     ops,
-//                     traverse: match last_seg {
-//                         Some(last) => OwnedTraverse::FirstChild(Box::new(last)),
-//                         None => OwnedTraverse::Halt,
-//                     },
-//                 })
-//             }
-//             TemplateNodeTypeBuilder::Text(_) => Some(OwnedPathSeg {
-//                 ops: vec![UpdateOp::StoreNode(n.id)],
-//                 traverse: dioxus_core::OwnedTraverse::Halt,
-//             }),
-//             TemplateNodeTypeBuilder::DynamicNode(_) => unreachable!(
-//                 "constructing path segment for dynamic nodes is handled in the parent node"
-//             ),
-//         }
-//     }
-// }
-
-// impl ToTokens for TemplateBuilder {
-//     fn to_tokens(&self, tokens: &mut TokenStream) {
-//         let Self {
-//             nodes,
-//             root_nodes,
-//             dynamic_context,
-//         } = self;
-
-//         let mut node_mapping = vec![None; dynamic_context.nodes.len()];
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::DynamicNode(idx) = &n.node_type {
-//                 node_mapping[*idx] = Some(n.id);
-//             }
-//         }
-//         let mut text_mapping = vec![Vec::new(); dynamic_context.text.len()];
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::Text(txt) = &n.node_type {
-//                 for seg in &txt.segments {
-//                     match seg {
-//                         TextTemplateSegment::Static(_) => (),
-//                         TextTemplateSegment::Dynamic(idx) => text_mapping[*idx].push(n.id),
-//                     }
-//                 }
-//             }
-//         }
-//         let mut attribute_mapping = vec![Vec::new(); dynamic_context.attributes.len()];
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
-//                 for (i, attr) in el.attributes.iter().enumerate() {
-//                     match attr.value {
-//                         TemplateAttributeValue::Static(_) => (),
-//                         TemplateAttributeValue::Dynamic(idx) => {
-//                             attribute_mapping[idx].push((n.id, i));
-//                         }
-//                     }
-//                 }
-//             }
-//         }
-//         let mut listener_mapping = Vec::new();
-//         for n in nodes {
-//             if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
-//                 if !el.listeners.is_empty() {
-//                     listener_mapping.push(n.id);
-//                 }
-//             }
-//         }
-
-//         let root_nodes = root_nodes.iter().map(|id| {
-//             let raw = id.0;
-//             quote! { TemplateNodeId(#raw) }
-//         });
-//         let node_mapping_quoted = node_mapping.iter().map(|op| match op {
-//             Some(id) => {
-//                 let raw_id = id.0;
-//                 quote! {Some(TemplateNodeId(#raw_id))}
-//             }
-//             None => quote! {None},
-//         });
-//         let text_mapping_quoted = text_mapping.iter().map(|inner| {
-//             let raw = inner.iter().map(|id| id.0);
-//             quote! {&[#(TemplateNodeId(#raw)),*]}
-//         });
-//         let attribute_mapping_quoted = attribute_mapping.iter().map(|inner| {
-//             let raw = inner.iter().map(|(id, _)| id.0);
-//             let indecies = inner.iter().map(|(_, idx)| idx);
-//             quote! {&[#((TemplateNodeId(#raw), #indecies)),*]}
-//         });
-//         let listener_mapping_quoted = listener_mapping.iter().map(|id| {
-//             let raw = id.0;
-//             quote! {TemplateNodeId(#raw)}
-//         });
-//         let mut nodes_quoted = TokenStream::new();
-//         for n in nodes {
-//             n.to_tokens(&mut nodes_quoted);
-//             quote! {,}.to_tokens(&mut nodes_quoted);
-//         }
-
-//         let dynamic_path = match self.dynamic_path() {
-//             Some(seg) => {
-//                 let seg = quote_owned_segment(seg);
-//                 quote! {Some(#seg)}
-//             }
-//             None => quote! {None},
-//         };
-
-//         let quoted = quote! {
-//             {
-//                 const __NODES: dioxus::prelude::StaticTemplateNodes = &[#nodes_quoted];
-//                 const __TEXT_MAPPING: &'static [&'static [dioxus::prelude::TemplateNodeId]] = &[#(#text_mapping_quoted),*];
-//                 const __ATTRIBUTE_MAPPING: &'static [&'static [(dioxus::prelude::TemplateNodeId, usize)]] = &[#(#attribute_mapping_quoted),*];
-//                 const __ROOT_NODES: &'static [dioxus::prelude::TemplateNodeId] = &[#(#root_nodes),*];
-//                 const __NODE_MAPPING: &'static [Option<dioxus::prelude::TemplateNodeId>] = &[#(#node_mapping_quoted),*];
-//                 const __NODES_WITH_LISTENERS: &'static [dioxus::prelude::TemplateNodeId] = &[#(#listener_mapping_quoted),*];
-//                 static __VOLITALE_MAPPING_INNER: dioxus::core::exports::once_cell::sync::Lazy<Vec<(dioxus::prelude::TemplateNodeId, usize)>> = dioxus::core::exports::once_cell::sync::Lazy::new(||{
-//                     // check each property to see if it is volatile
-//                     let mut volatile = Vec::new();
-//                     for n in __NODES {
-//                         if let TemplateNodeType::Element(el) = &n.node_type {
-//                             for (i, attr) in el.attributes.iter().enumerate() {
-//                                 if attr.attribute.volatile {
-//                                     volatile.push((n.id, i));
-//                                 }
-//                             }
-//                         }
-//                     }
-//                     volatile
-//                 });
-//                 static __VOLITALE_MAPPING: &'static dioxus::core::exports::once_cell::sync::Lazy<Vec<(dioxus::prelude::TemplateNodeId, usize)>> = &__VOLITALE_MAPPING_INNER;
-//                 static __STATIC_VOLITALE_MAPPING: dioxus::prelude::LazyStaticVec<(dioxus::prelude::TemplateNodeId, usize)> = LazyStaticVec(__VOLITALE_MAPPING);
-//                 static __TEMPLATE: dioxus::prelude::Template = Template::Static(&StaticTemplate {
-//                     nodes: __NODES,
-//                     root_nodes: __ROOT_NODES,
-//                     dynamic_mapping: StaticDynamicNodeMapping::new(__NODE_MAPPING, __TEXT_MAPPING, __ATTRIBUTE_MAPPING, __STATIC_VOLITALE_MAPPING, __NODES_WITH_LISTENERS),
-//                     dynamic_path: #dynamic_path,
-//                 });
-
-//                 let __bump = __cx.bump();
-//                 __cx.template_ref(dioxus::prelude::TemplateId(get_line_num!()), __TEMPLATE.clone(), #dynamic_context)
-//             }
-//         };
-
-//         tokens.append_all(quoted)
-//     }
-// }
-
-// #[derive(Default, Clone, Debug)]
-// pub struct DynamicTemplateContextBuilder {
-//     nodes: Vec<BodyNode>,
-//     text: Vec<FormattedSegment>,
-//     attributes: Vec<TokenStream>,
-//     listeners: Vec<(String, Expr)>,
-//     key: Option<TokenStream>,
-// }
-
-// impl DynamicTemplateContextBuilder {
-//     fn add_node(&mut self, node: BodyNode) -> usize {
-//         let node_id = self.nodes.len();
-
-//         self.nodes.push(node);
-
-//         node_id
-//     }
-
-//     fn add_text(&mut self, text: FormattedSegment) -> usize {
-//         let text_id = self.text.len();
-
-//         self.text.push(text);
-
-//         text_id
-//     }
-
-//     fn add_attr(&mut self, attr: TokenStream) -> usize {
-//         let attr_id = self.attributes.len();
-
-//         self.attributes.push(attr);
-
-//         attr_id
-//     }
-
-//     fn add_listener(&mut self, name: Ident, listener: Expr) -> usize {
-//         let listener_id = self.listeners.len();
-
-//         self.listeners.push((name.to_string(), listener));
-
-//         listener_id
-//     }
-
-//     fn add_key(&mut self, key: TokenStream) {
-//         self.key = Some(key);
-//     }
-// }
-
-// impl ToTokens for DynamicTemplateContextBuilder {
-//     fn to_tokens(&self, tokens: &mut TokenStream) {
-//         let nodes = &self.nodes;
-//         let text = &self.text;
-//         let attributes = &self.attributes;
-//         let listeners_names = self
-//             .listeners
-//             .iter()
-//             .map(|(n, _)| syn::parse_str::<Ident>(n).expect(n));
-//         let listeners_exprs = self.listeners.iter().map(|(_, e)| e);
-//         let key = match &self.key {
-//             Some(k) => quote!(Some(#k)),
-//             None => quote!(None),
-//         };
-//         tokens.append_all(quote! {
-//             TemplateContext {
-//                 nodes: __cx.bump().alloc([#(#nodes),*]),
-//                 text_segments: __cx.bump().alloc([#(&*dioxus::core::exports::bumpalo::format!(in __bump, "{}", #text).into_bump_str()),*]),
-//                 attributes: __cx.bump().alloc([#({#attributes}.into_value(__cx.bump())),*]),
-//                 listeners: __cx.bump().alloc([#(dioxus_elements::on::#listeners_names(__cx, #listeners_exprs)),*]),
-//                 key: #key,
-//             }
-//         })
-//     }
-// }
-
-// fn quote_owned_segment(seg: OwnedPathSeg) -> proc_macro2::TokenStream {
-//     let OwnedPathSeg { ops, traverse } = seg;
-
-//     let ops = ops
-//         .into_iter()
-//         .map(|op| match op {
-//             UpdateOp::StoreNode(id) => {
-//                 let id = quote_template_node_id(id);
-//                 quote!(UpdateOp::StoreNode(#id))
-//             }
-//             UpdateOp::InsertBefore(id) => {
-//                 let id = quote_template_node_id(id);
-//                 quote!(UpdateOp::InsertBefore(#id))
-//             }
-//             UpdateOp::InsertAfter(id) => {
-//                 let id = quote_template_node_id(id);
-//                 quote!(UpdateOp::InsertAfter(#id))
-//             }
-//             UpdateOp::AppendChild(id) => {
-//                 let id = quote_template_node_id(id);
-//                 quote!(UpdateOp::AppendChild(#id))
-//             }
-//         })
-//         .collect::<Vec<_>>();
-
-//     let traverse = quote_owned_traverse(traverse);
-
-//     quote! {
-//         StaticPathSeg {
-//             ops: &[#(#ops),*],
-//             traverse: #traverse,
-//         }
-//     }
-// }
-
-// fn quote_owned_traverse(traverse: OwnedTraverse) -> proc_macro2::TokenStream {
-//     match traverse {
-//         OwnedTraverse::Halt => {
-//             quote! {StaticTraverse::Halt}
-//         }
-//         OwnedTraverse::FirstChild(seg) => {
-//             let seg = quote_owned_segment(*seg);
-//             quote! {StaticTraverse::FirstChild(&#seg)}
-//         }
-//         OwnedTraverse::NextSibling(seg) => {
-//             let seg = quote_owned_segment(*seg);
-//             quote! {StaticTraverse::NextSibling(&#seg)}
-//         }
-//         OwnedTraverse::Both(b) => {
-//             let (child, sibling) = *b;
-//             let child = quote_owned_segment(child);
-//             let sibling = quote_owned_segment(sibling);
-//             quote! {StaticTraverse::Both(&(#child, #sibling))}
-//         }
-//     }
-// }
-
-// fn quote_template_node_id(id: TemplateNodeId) -> proc_macro2::TokenStream {
-//     let raw = id.0;
-//     quote! {
-//         TemplateNodeId(#raw)
-//     }
-// }