首页 发现 帮助
登录
lenn
/
dioxus-mirror
镜像自地址 https://github.com/DioxusLabs/dioxus.git
1
0
派生 0
文件 工单管理 0 Wiki
浏览代码

Feat: remove old code

Jonathan Kelley 4 年之前
父节点
2284b35782
当前提交
3de54d0b52
共有 9 个文件被更改，包括 37 次插入 和 2054 次删除
合并视图 显示文件统计
  1. 29 0
      packages/core-macro/src/rsxt.rs
  2. 0 589
      packages/core/old/builderconstructors.rs
  3. 0 1006
      packages/core/old/old.rs
  4. 0 80
      packages/core/old/patch.rs
  5. 0 329
      packages/core/old/percydiff.rs
  6. 0 40
      packages/core/old/validation.rs
  7. 0 0
      packages/core/old/virtual_node.rs
  8. 1 1
      packages/core/src/virtual_dom.rs
  9. 7 9
      packages/ssr/src/tostring.rs

+ 29 - 0
packages/core-macro/src/rsxt.rs
查看文件 

@@ -497,3 +497,32 @@ fn try_parse_bracketed(stream: &ParseBuffer) -> Result<Expr> {
 
     syn::braced!(content in stream);
 
     syn::braced!(content in stream);
 
     content.parse()
 
     content.parse()
 
 }
 
 }
 
+
 
+// // Used to uniquely identify elements that contain closures so that the DomUpdater can
 
+// // look them up by their unique id.
 
+// // When the DomUpdater sees that the element no longer exists it will drop all of it's
 
+// // Rc'd Closures for those events.
 
+// // It doesn't quite make sense to keep this here, perhaps just in the html crate?
 
+// // Dioxus itself shouldn't be concerned with the attribute names
 
+// // a ftk!
 
+// static SELF_CLOSING_TAGS: Lazy<HashSet<&'static str>> = Lazy::new(|| {
 
+//     [
 
+//         "area", "base", "br", "col", "hr", "img", "input", "link", "meta", "param", "command",
 
+//         "keygen", "source",
 
+//     ]
 
+//     .iter()
 
+//     .cloned()
 
+//     .collect()
 
+// });
 
+
 
+// /// Whether or not this tag is self closing
 
+// ///
 
+// /// ```ignore
 
+// /// use dioxus_core::validation::is_self_closing;
 
+// /// assert_eq!(is_self_closing("br"), true);
 
+// /// assert_eq!(is_self_closing("div"), false);
 
+// /// ```
 
+// pub fn is_self_closing(tag: &str) -> bool {
 
+//     SELF_CLOSING_TAGS.contains(tag)
 
+//     // SELF_CLOSING_TAGS.contains(tag) || is_self_closing_svg_tag(tag)
 
+// }

+ 0 - 589
packages/core/old/builderconstructors.rs
查看文件 

@@ -1,589 +0,0 @@
 
-// we don't want to necessarily adhere to the spec for dioxus core
 
-// 3rd party libs can implement their own builders if they want
 
-
 
-// macro_rules! builder_constructors {
 
-//     ( $(
 
-//         $(#[$attr:meta])*
 
-//         $name:ident;
 
-//     )* ) => {
 
-//         $(
 
-//             $(#[$attr])*
 
-//             #[inline]
 
-//             pub fn $name<'a, B>(
 
-//                 bump: B,
 
-//             ) -> ElementBuilder<
 
-//                 'a,
 
-//                 bumpalo::collections::Vec<'a, Listener<'a>>,
 
-//                 bumpalo::collections::Vec<'a, Attribute<'a>>,
 
-//                 bumpalo::collections::Vec<'a, VNode<'a>>,
 
-//             >
 
-//             where
 
-//                 B: Into<&'a Bump>
 
-//             {
 
-//                 ElementBuilder::new(bump, stringify!($name))
 
-//             }
 
-//         )*
 
-//     };
 
-//     ( $(
 
-//         $(#[$attr:meta])*
 
-//         $name:ident <> $namespace:tt;
 
-//     )* ) => {
 
-//         $(
 
-//             $(#[$attr])*
 
-//             #[inline]
 
-//             pub fn $name<'a>(
 
-//                 bump: &'a Bump,
 
-//             ) -> ElementBuilder<
 
-//                 'a,
 
-//                 bumpalo::collections::Vec<'a, Listener<'a>>,
 
-//                 bumpalo::collections::Vec<'a, Attribute<'a>>,
 
-//                 bumpalo::collections::Vec<'a, VNode<'a>>,
 
-//             > {
 
-//                 let builder = ElementBuilder::new(bump, stringify!($name));
 
-//                 builder.namespace(Some($namespace))
 
-//             }
 
-//         )*
 
-//     }
 
-// }
 
-
 
-// // Organized in the same order as
 
-// // https://developer.mozilla.org/en-US/docs/Web/HTML/Element
 
-// //
 
-// // Does not include obsolete elements.
 
-// builder_constructors! {
 
-//     // Document metadata
 
-
 
-//     /// Build a
 
-//     /// [`<base>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base)
 
-//     /// element.
 
-//     base;
 
-//     /// Build a
 
-//     /// [`<head>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/head)
 
-//     /// element.
 
-//     head;
 
-//     /// Build a
 
-//     /// [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
 
-//     /// element.
 
-//     link;
 
-//     /// Build a
 
-//     /// [`<meta>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta)
 
-//     /// element.
 
-//     meta;
 
-//     /// Build a
 
-//     /// [`<style>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style)
 
-//     /// element.
 
-//     style;
 
-//     /// Build a
 
-//     /// [`<title>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title)
 
-//     /// element.
 
-//     title;
 
-
 
-//     // Sectioning root
 
-
 
-//     /// Build a
 
-//     /// [`<body>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body)
 
-//     /// element.
 
-//     body;
 
-
 
-//     // Content sectioning
 
-
 
-//     /// Build a
 
-//     /// [`<address>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/address)
 
-//     /// element.
 
-//     address;
 
-//     /// Build a
 
-//     /// [`<article>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/article)
 
-//     /// element.
 
-//     article;
 
-//     /// Build a
 
-//     /// [`<aside>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/aside)
 
-//     /// element.
 
-//     aside;
 
-//     /// Build a
 
-//     /// [`<footer>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/footer)
 
-//     /// element.
 
-//     footer;
 
-//     /// Build a
 
-//     /// [`<header>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/header)
 
-//     /// element.
 
-//     header;
 
-//     /// Build a
 
-//     /// [`<h1>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h1)
 
-//     /// element.
 
-//     h1;
 
-//     /// Build a
 
-//     /// [`<h2>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h2)
 
-//     /// element.
 
-//     h2;
 
-//     /// Build a
 
-//     /// [`<h3>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h3)
 
-//     /// element.
 
-//     h3;
 
-//     /// Build a
 
-//     /// [`<h4>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h4)
 
-//     /// element.
 
-//     h4;
 
-//     /// Build a
 
-//     /// [`<h5>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h5)
 
-//     /// element.
 
-//     h5;
 
-//     /// Build a
 
-//     /// [`<h6>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h6)
 
-//     /// element.
 
-//     h6;
 
-//     /// Build a
 
-//     /// [`<hgroup>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/hgroup)
 
-//     /// element.
 
-//     hgroup;
 
-//     /// Build a
 
-//     /// [`<main>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/main)
 
-//     /// element.
 
-//     main;
 
-//     /// Build a
 
-//     /// [`<nav>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/nav)
 
-//     /// element.
 
-//     nav;
 
-//     /// Build a
 
-//     /// [`<section>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/section)
 
-//     /// element.
 
-//     section;
 
-
 
-//     // Text content
 
-
 
-//     /// Build a
 
-//     /// [`<blockquote>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blockquote)
 
-//     /// element.
 
-//     blockquote;
 
-//     /// Build a
 
-//     /// [`<dd>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dd)
 
-//     /// element.
 
-//     dd;
 
-//     /// Build a
 
-//     /// [`<div>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/div)
 
-//     /// element.
 
-//     div;
 
-//     /// Build a
 
-//     /// [`<dl>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dl)
 
-//     /// element.
 
-//     dl;
 
-//     /// Build a
 
-//     /// [`<dt>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dt)
 
-//     /// element.
 
-//     dt;
 
-//     /// Build a
 
-//     /// [`<figcaption>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figcaption)
 
-//     /// element.
 
-//     figcaption;
 
-//     /// Build a
 
-//     /// [`<figure>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figure)
 
-//     /// element.
 
-//     figure;
 
-//     /// Build a
 
-//     /// [`<hr>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/hr)
 
-//     /// element.
 
-//     hr;
 
-//     /// Build a
 
-//     /// [`<li>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/li)
 
-//     /// element.
 
-//     li;
 
-//     /// Build a
 
-//     /// [`<ol>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ol)
 
-//     /// element.
 
-//     ol;
 
-//     /// Build a
 
-//     /// [`<p>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/p)
 
-//     /// element.
 
-//     p;
 
-//     /// Build a
 
-//     /// [`<pre>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/pre)
 
-//     /// element.
 
-//     pre;
 
-//     /// Build a
 
-//     /// [`<ul>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ul)
 
-//     /// element.
 
-//     ul;
 
-
 
-//     // Inline text semantics
 
-
 
-//     /// Build a
 
-//     /// [`<a>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a)
 
-//     /// element.
 
-//     a;
 
-//     /// Build a
 
-//     /// [`<abbr>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/abbr)
 
-//     /// element.
 
-//     abbr;
 
-//     /// Build a
 
-//     /// [`<b>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/b)
 
-//     /// element.
 
-//     b;
 
-//     /// Build a
 
-//     /// [`<bdi>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdi)
 
-//     /// element.
 
-//     bdi;
 
-//     /// Build a
 
-//     /// [`<bdo>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdo)
 
-//     /// element.
 
-//     bdo;
 
-//     /// Build a
 
-//     /// [`<br>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/br)
 
-//     /// element.
 
-//     br;
 
-//     /// Build a
 
-//     /// [`<cite>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/cite)
 
-//     /// element.
 
-//     cite;
 
-//     /// Build a
 
-//     /// [`<code>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/code)
 
-//     /// element.
 
-//     code;
 
-//     /// Build a
 
-//     /// [`<data>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/data)
 
-//     /// element.
 
-//     data;
 
-//     /// Build a
 
-//     /// [`<dfn>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dfn)
 
-//     /// element.
 
-//     dfn;
 
-//     /// Build a
 
-//     /// [`<em>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/em)
 
-//     /// element.
 
-//     em;
 
-//     /// Build a
 
-//     /// [`<i>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/i)
 
-//     /// element.
 
-//     i;
 
-//     /// Build a
 
-//     /// [`<kbd>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/kbd)
 
-//     /// element.
 
-//     kbd;
 
-//     /// Build a
 
-//     /// [`<mark>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/mark)
 
-//     /// element.
 
-//     mark;
 
-//     /// Build a
 
-//     /// [`<q>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/q)
 
-//     /// element.
 
-//     q;
 
-//     /// Build a
 
-//     /// [`<rb>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/rb)
 
-//     /// element.
 
-//     rb;
 
-//     /// Build a
 
-//     /// [`<rp>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/rp)
 
-//     /// element.
 
-//     rp;
 
-//     /// Build a
 
-//     /// [`<rt>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/rt)
 
-//     /// element.
 
-//     rt;
 
-//     /// Build a
 
-//     /// [`<rtc>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/rtc)
 
-//     /// element.
 
-//     rtc;
 
-//     /// Build a
 
-//     /// [`<ruby>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ruby)
 
-//     /// element.
 
-//     ruby;
 
-//     /// Build a
 
-//     /// [`<s>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/s)
 
-//     /// element.
 
-//     s;
 
-//     /// Build a
 
-//     /// [`<samp>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/samp)
 
-//     /// element.
 
-//     samp;
 
-//     /// Build a
 
-//     /// [`<small>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/small)
 
-//     /// element.
 
-//     small;
 
-//     /// Build a
 
-//     /// [`<span>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/span)
 
-//     /// element.
 
-//     span;
 
-//     /// Build a
 
-//     /// [`<strong>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/strong)
 
-//     /// element.
 
-//     strong;
 
-//     /// Build a
 
-//     /// [`<sub>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/sub)
 
-//     /// element.
 
-//     sub;
 
-//     /// Build a
 
-//     /// [`<sup>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/sup)
 
-//     /// element.
 
-//     sup;
 
-//     /// Build a
 
-//     /// [`<time>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/time)
 
-//     /// element.
 
-//     time;
 
-//     /// Build a
 
-//     /// [`<u>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/u)
 
-//     /// element.
 
-//     u;
 
-//     /// Build a
 
-//     /// [`<var>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/var)
 
-//     /// element.
 
-//     var;
 
-//     /// Build a
 
-//     /// [`<wbr>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/wbr)
 
-//     /// element.
 
-//     wbr;
 
-
 
-//     // Image and multimedia
 
-
 
-//     /// Build a
 
-//     /// [`<area>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/area)
 
-//     /// element.
 
-//     area;
 
-//     /// Build a
 
-//     /// [`<audio>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/audio)
 
-//     /// element.
 
-//     audio;
 
-//     /// Build a
 
-//     /// [`<img>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img)
 
-//     /// element.
 
-//     img;
 
-//     /// Build a
 
-//     /// [`<map>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/map)
 
-//     /// element.
 
-//     map;
 
-//     /// Build a
 
-//     /// [`<track>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/track)
 
-//     /// element.
 
-//     track;
 
-//     /// Build a
 
-//     /// [`<video>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video)
 
-//     /// element.
 
-//     video;
 
-
 
-//     // Embedded content
 
-
 
-//     /// Build a
 
-//     /// [`<embed>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/embed)
 
-//     /// element.
 
-//     embed;
 
-//     /// Build a
 
-//     /// [`<iframe>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe)
 
-//     /// element.
 
-//     iframe;
 
-//     /// Build a
 
-//     /// [`<object>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/object)
 
-//     /// element.
 
-//     object;
 
-//     /// Build a
 
-//     /// [`<param>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/param)
 
-//     /// element.
 
-//     param;
 
-//     /// Build a
 
-//     /// [`<picture>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/picture)
 
-//     /// element.
 
-//     picture;
 
-//     /// Build a
 
-//     /// [`<source>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/source)
 
-//     /// element.
 
-//     source;
 
-
 
-//     // Scripting
 
-
 
-//     /// Build a
 
-//     /// [`<canvas>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas)
 
-//     /// element.
 
-//     canvas;
 
-//     /// Build a
 
-//     /// [`<noscript>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript)
 
-//     /// element.
 
-//     noscript;
 
-//     /// Build a
 
-//     /// [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
 
-//     /// element.
 
-//     script;
 
-
 
-//     // Demarcating edits
 
-
 
-//     /// Build a
 
-//     /// [`<del>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/del)
 
-//     /// element.
 
-//     del;
 
-//     /// Build a
 
-//     /// [`<ins>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ins)
 
-//     /// element.
 
-//     ins;
 
-
 
-//     // Table content
 
-
 
-//     /// Build a
 
-//     /// [`<caption>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/caption)
 
-//     /// element.
 
-//     caption;
 
-//     /// Build a
 
-//     /// [`<col>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/col)
 
-//     /// element.
 
-//     col;
 
-//     /// Build a
 
-//     /// [`<colgroup>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/colgroup)
 
-//     /// element.
 
-//     colgroup;
 
-//     /// Build a
 
-//     /// [`<table>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/table)
 
-//     /// element.
 
-//     table;
 
-//     /// Build a
 
-//     /// [`<tbody>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tbody)
 
-//     /// element.
 
-//     tbody;
 
-//     /// Build a
 
-//     /// [`<td>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td)
 
-//     /// element.
 
-//     td;
 
-//     /// Build a
 
-//     /// [`<tfoot>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tfoot)
 
-//     /// element.
 
-//     tfoot;
 
-//     /// Build a
 
-//     /// [`<th>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/th)
 
-//     /// element.
 
-//     th;
 
-//     /// Build a
 
-//     /// [`<thead>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/thead)
 
-//     /// element.
 
-//     thead;
 
-//     /// Build a
 
-//     /// [`<tr>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tr)
 
-//     /// element.
 
-//     tr;
 
-
 
-//     // Forms
 
-
 
-//     /// Build a
 
-//     /// [`<button>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button)
 
-//     /// element.
 
-//     button;
 
-//     /// Build a
 
-//     /// [`<datalist>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/datalist)
 
-//     /// element.
 
-//     datalist;
 
-//     /// Build a
 
-//     /// [`<fieldset>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/fieldset)
 
-//     /// element.
 
-//     fieldset;
 
-//     /// Build a
 
-//     /// [`<form>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form)
 
-//     /// element.
 
-//     form;
 
-//     /// Build a
 
-//     /// [`<input>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input)
 
-//     /// element.
 
-//     input;
 
-//     /// Build a
 
-//     /// [`<label>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/label)
 
-//     /// element.
 
-//     label;
 
-//     /// Build a
 
-//     /// [`<legend>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/legend)
 
-//     /// element.
 
-//     legend;
 
-//     /// Build a
 
-//     /// [`<meter>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meter)
 
-//     /// element.
 
-//     meter;
 
-//     /// Build a
 
-//     /// [`<optgroup>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/optgroup)
 
-//     /// element.
 
-//     optgroup;
 
-//     /// Build a
 
-//     /// [`<option>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/option)
 
-//     /// element.
 
-//     option;
 
-//     /// Build a
 
-//     /// [`<output>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/output)
 
-//     /// element.
 
-//     output;
 
-//     /// Build a
 
-//     /// [`<progress>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/progress)
 
-//     /// element.
 
-//     progress;
 
-//     /// Build a
 
-//     /// [`<select>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/select)
 
-//     /// element.
 
-//     select;
 
-//     /// Build a
 
-//     /// [`<textarea>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/textarea)
 
-//     /// element.
 
-//     textarea;
 
-
 
-//     // Interactive elements
 
-
 
-//     /// Build a
 
-//     /// [`<details>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details)
 
-//     /// element.
 
-//     details;
 
-//     /// Build a
 
-//     /// [`<dialog>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog)
 
-//     /// element.
 
-//     dialog;
 
-//     /// Build a
 
-//     /// [`<menu>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/menu)
 
-//     /// element.
 
-//     menu;
 
-//     /// Build a
 
-//     /// [`<menuitem>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/menuitem)
 
-//     /// element.
 
-//     menuitem;
 
-//     /// Build a
 
-//     /// [`<summary>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/summary)
 
-//     /// element.
 
-//     summary;
 
-
 
-//     // Web components
 
-
 
-//     /// Build a
 
-//     /// [`<slot>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot)
 
-//     /// element.
 
-//     slot;
 
-//     /// Build a
 
-//     /// [`<template>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)
 
-//     /// element.
 
-//     template;
 
-// }
 
-
 
-// builder_constructors! {
 
-//     // SVG components
 
-
 
-//     /// Build a
 
-//     /// [`<svg>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/svg)
 
-//     /// element.
 
-//     svg <> "http://www.w3.org/2000/svg" ;
 
-//     /// Build a
 
-//     /// [`<path>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/path)
 
-//     /// element.
 
-//     path <> "http://www.w3.org/2000/svg";
 
-//     /// Build a
 
-//     /// [`<circle>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/circle)
 
-//     /// element.
 
-//     circle <>  "http://www.w3.org/2000/svg";
 
-//     /// Build a
 
-//     /// [`<ellipse>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/ellipse)
 
-//     /// element.
 
-//     ellipse <> "http://www.w3.org/2000/svg";
 
-//     /// Build a
 
-//     /// [`<line>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/line)
 
-//     /// element.
 
-//     line <> "http://www.w3.org/2000/svg";
 
-//     /// Build a
 
-//     /// [`<polygon>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/polygon)
 
-//     /// element.
 
-//     polygon <> "http://www.w3.org/2000/svg";
 
-//     /// Build a
 
-//     /// [`<polyline>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/polyline)
 
-//     /// element.
 
-//     polyline <> "http://www.w3.org/2000/svg";
 
-//     /// Build a
 
-//     /// [`<rect>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/rect)
 
-//     /// element.
 
-//     rect <> "http://www.w3.org/2000/svg";
 
-//     /// Build a
 
-//     /// [`<image>`](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/image)
 
-//     /// element.
 
-//     image <> "http://www.w3.org/2000/svg";
 
-// }

+ 0 - 1006
packages/core/old/old.rs
查看文件 

@@ -1,1006 +0,0 @@
 
-mod old {
 
-
 
-    // #![feature(type_alias_impl_trait)]
 
-    //
 
-    use std::future::Future;
 
-
 
-    trait Props {}
 
-    struct Context<T: Props> {
 
-        _props: std::marker::PhantomData<T>,
 
-    }
 
-    struct VNode {}
 
-
 
-    // type FC<T: Props> = fn(&mut Context<T>) -> VNode;
 
-    // type FC<T: Props> = fn(&mut Context<T>) -> Box<dyn Future<Output = VNode>>;
 
-
 
-    impl Props for () {}
 
-
 
-    // async fn some_component(g: &mut Context<()>) -> VNode {
 
-    //     rsx! {
 
-    //         <div>
 
-
 
-    //         </div>
 
-    //     }
 
-    // }
 
-    // Absolve ourselves of any type data about the context itself
 
-    trait ContextApplier {
 
-        fn use_hook<O, H>(
 
-            &mut self,
 
-            initializer: impl FnOnce() -> H,
 
-            runner: impl Fn(&mut H) -> O,
 
-            tear_down: impl Fn(&mut H),
 
-        ) -> O;
 
-    }
 
-    impl<T: Props> ContextApplier for Context<T> {
 
-        fn use_hook<O, H>(
 
-            &mut self,
 
-            initializer: impl FnOnce() -> H,
 
-            runner: impl Fn(&mut H) -> O,
 
-            tear_down: impl Fn(&mut H),
 
-        ) -> O {
 
-            todo!()
 
-        }
 
-    }
 
-
 
-    fn use_state<T>(c: &mut impl ContextApplier, g: impl Fn() -> T) -> T {
 
-        c.use_hook(|| {}, |_| {}, |_| {});
 
-        g()
 
-    }
 
-
 
-    enum SomeComponent {
 
-        Imperative,
 
-        Async,
 
-    }
 
-
 
-    // impl<F, G> From<F> for SomeComponent
 
-    // where
 
-    //     F: Fn() -> G,
 
-    //     G: Future<Output = ()>,
 
-    // {
 
-    //     fn from(_: F) -> Self {
 
-    //         SomeComponent::Async
 
-    //     }
 
-    // }
 
-
 
-    // impl From<fn() -> ()> for SomeComponent {
 
-    //     fn from(_: F) -> Self {
 
-    //         SomeComponent::Async
 
-    //     }
 
-    // }
 
-    // impl<F> Into<SomeComponent> for fn() -> F
 
-    // where
 
-    //     F: Future<Output = ()>,
 
-    // {
 
-    //     fn into(self) -> SomeComponent {
 
-    //         todo!()
 
-    //     }
 
-    // }
 
-
 
-    // #[test]
 
-    // fn test() {
 
-    //     let b: SomeComponent = test_comp.into();
 
-    // }
 
-
 
-    // Does this make sense?
 
-    // Any component labeled with async can halt its rendering, but won't be able to process updates?
 
-    // Or, those updates can still happen virtually, just not propogated into the view?
 
-    // async fn test_comp() -> () {
 
-    //     timer::new(300).await;
 
-    //     html! {
 
-    //         <div>
 
-    //             "hello world!"
 
-    //         </div>
 
-    //     }
 
-    // }
 
-
 
-    // fn use_state<T: Props>(c: &mut Context<T>) {}
 
-
 
-    // async fn another_component(ctx: &mut Context<()>) -> VNode {
 
-    //     // delay the re-render until component when the future is ready
 
-    //     // "use_future" loads the promise and provides a value (aka a loadable)
 
-    //     let value = use_effect(move || async {
 
-    //         get_value().join(timer::new(300));
 
-    //         set_value(blah);
 
-    //     });
 
-
 
-    //     rsx! {
 
-    //         <Suspense fallback={<div>"Loading..."</div>}>
 
-    //             <div>
 
-    //                 "hello {name}!"
 
-    //             </div>
 
-    //         <Suspense />
 
-    //     }
 
-    // }
 
-
 
-    /*
 
-
 
-    Rationale
 
-    Today, you can do use_async and do some async operations,
 
-
 
-
 
-
 
-
 
-
 
-
 
-
 
-    */
 
-    // type FC<P: Props> = fn(&mut Context<P>) -> VNode;
 
-
 
-    // static Example: FC<()> = |_| async {
 
-    //     // some async work
 
-    // };
 
-
 
-    // type FC2 = fn() -> impl Future<Output = ()>;
 
-    // struct fc<P: Props>(fn(&mut Context<P>) -> G);
 
-    // fn blah<P: Props, G: Future<Output = VNode>>(a: fn(&mut Context<P>) -> G) {}
 
-
 
-    // static Example2: FC2<()> = fc(|_| async { VNode {} });
 
-    // static Example2: () = blah(|_: &mut Context<()>| async { VNode {} });
 
-
 
-    // static Example: FC<()> = |_| {
 
-    //     let g = async { VNode {} };
 
-    //     Box::new(g)
 
-    // };
 
-
 
-    // static Example2:  = || {};
 
-
 
-    // type FA<R: Future<Output = i32>> = fn(i32) -> R;
 
-
 
-    // async fn my_component()
 
-    // static MyThing: FA<dyn Future<Output = i32>> = |_| async { 10 };
 
-
 
-    // type SomeFn = fn() -> ();
 
-
 
-    // static MyFn: SomeFn = || {};
 
-}
 
-
 
-mod old2 {
 
-    mod vdom {
 
-        //! Virtual DOM implementation
 
-        use super::*;
 
-
 
-        pub struct VDom {
 
-            patches: Vec<Patch>,
 
-        }
 
-
 
-        impl VDom {
 
-            // fn new(root: ComponentFn) -> Self {
 
-            //     let scope = Scope::new();
 
-            //     Self {}
 
-            // }
 
-        }
 
-    }
 
-
 
-    mod nodes {}
 
-
 
-    mod patch {}
 
-
 
-    mod scope {
 
-        //! Wrappers around components
 
-
 
-        pub struct Scope {}
 
-
 
-        impl Scope {
 
-            fn new() -> Self {
 
-                Self {}
 
-            }
 
-        }
 
-    }
 
-
 
-    mod context {}
 
-
 
-    struct EventListener {}
 
-
 
-    struct VNode {
 
-        /// key-value pairs of attributes
 
-        attributes: Vec<(&'static str, &'static str)>,
 
-
 
-        /// onclick/onhover/on etc listeners
 
-        /// goal is to standardize around a set of cross-platform listeners?
 
-        listeners: Vec<EventListener>,
 
-
 
-        /// Direct children, non arena-allocated
 
-        children: Vec<VNode>,
 
-    }
 
-
 
-    enum ElementType {
 
-        div,
 
-        p,
 
-        a,
 
-        img,
 
-    }
 
-
 
-    struct ComponentContext {}
 
-    type ComponentFn = fn(ctx: &ComponentContext) -> VNode;
 
-
 
-    enum Patch {}
 
-
 
-    mod tests {
 
-        use super::*;
 
-
 
-        /// Ensure components can be made from the raw components
 
-        #[test]
 
-        fn simple_test() {
 
-            fn component(ctx: &ComponentContext) -> VNode {
 
-                println!("Running component");
 
-                VNode {}
 
-            }
 
-
 
-            let dom = VDom::new(component);
 
-        }
 
-
 
-        /// Ensure components can be made from the raw components
 
-        #[test]
 
-        fn simple_test_closure() {
 
-            let component: ComponentFn = |ctx| {
 
-                println!("Running component");
 
-                VNode {}
 
-            };
 
-
 
-            let dom = VDom::new(component);
 
-        }
 
-    }
 
-}
 
-
 
-mod text {
 
-    //! Old methods that clouded the element implementation
 
-    //! These all add a dedicated text renderer implementation
 
-
 
-    mod vnode {
 
-
 
-        impl From<&str> for VNode {
 
-            fn from(other: &str) -> Self {
 
-                VNode::text(other)
 
-            }
 
-        }
 
-
 
-        impl From<String> for VNode {
 
-            fn from(other: String) -> Self {
 
-                VNode::text(other.as_str())
 
-            }
 
-        }
 
-
 
-        // -----------------------------------------------
 
-        //  Allow VNodes to be iterated for map-based UI
 
-        // -----------------------------------------------
 
-        impl IntoIterator for VNode {
 
-            type Item = VNode;
 
-            // TODO: Is this possible with an array [VNode] instead of a vec?
 
-            type IntoIter = ::std::vec::IntoIter<VNode>;
 
-
 
-            fn into_iter(self) -> Self::IntoIter {
 
-                vec![self].into_iter()
 
-            }
 
-        }
 
-
 
-        impl Into<::std::vec::IntoIter<VNode>> for VNode {
 
-            fn into(self) -> ::std::vec::IntoIter<VNode> {
 
-                self.into_iter()
 
-            }
 
-        }
 
-
 
-        // -----------------------------------------------
 
-        //  Allow debug/display adherent to the HTML spec
 
-        // -----------------------------------------------
 
-        use std::fmt;
 
-        impl fmt::Debug for VNode {
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                match self {
 
-                    VNode::Element(e) => write!(f, "Node::{:?}", e),
 
-                    VNode::Text(t) => write!(f, "Node::{:?}", t),
 
-                    VNode::Component(c) => write!(f, "Node::{:?}", c),
 
-                }
 
-            }
 
-        }
 
-
 
-        // Turn a VNode into an HTML string (delegate impl to variants)
 
-        impl fmt::Display for VNode {
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                match self {
 
-                    VNode::Element(element) => write!(f, "{}", element),
 
-                    VNode::Text(text) => write!(f, "{}", text),
 
-                    VNode::Component(c) => write!(f, "{}", c),
 
-                }
 
-            }
 
-        }
 
-    }
 
-
 
-    mod velement {
 
-        // -----------------------------------------------
 
-        //  Allow debug/display adherent to the HTML spec
 
-        // -----------------------------------------------
 
-        use std::fmt;
 
-        impl fmt::Debug for VElement {
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                write!(
 
-                    f,
 
-                    "Element(<{}>, attrs: {:?}, children: {:?})",
 
-                    self.tag, self.attrs, self.children,
 
-                )
 
-            }
 
-        }
 
-
 
-        impl fmt::Display for VElement {
 
-            // Turn a VElement and all of it's children (recursively) into an HTML string
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                write!(f, "<{}", self.tag).unwrap();
 
-
 
-                for (attr, value) in self.attrs.iter() {
 
-                    write!(f, r#" {}="{}""#, attr, value)?;
 
-                }
 
-
 
-                write!(f, ">")?;
 
-
 
-                for child in self.children.iter() {
 
-                    write!(f, "{}", child.to_string())?;
 
-                }
 
-
 
-                if !crate::validation::is_self_closing(&self.tag) {
 
-                    write!(f, "</{}>", self.tag)?;
 
-                }
 
-
 
-                Ok(())
 
-            }
 
-        }
 
-    }
 
-
 
-    mod vtext {
 
-        // -----------------------------------------------
 
-        //  Convert from primitives directly into VText
 
-        // -----------------------------------------------
 
-        impl From<&str> for VText {
 
-            fn from(text: &str) -> Self {
 
-                VText {
 
-                    text: text.to_string(),
 
-                }
 
-            }
 
-        }
 
-
 
-        impl From<String> for VText {
 
-            fn from(text: String) -> Self {
 
-                VText { text }
 
-            }
 
-        }
 
-
 
-        // -----------------------------------------------
 
-        //  Allow debug/display adherent to the HTML spec
 
-        // -----------------------------------------------
 
-        use std::fmt;
 
-        impl fmt::Debug for VText {
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                write!(f, "Text({})", self.text)
 
-            }
 
-        }
 
-
 
-        // Turn a VText into an HTML string
 
-        impl fmt::Display for VText {
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                write!(f, "{}", self.text)
 
-            }
 
-        }
 
-    }
 
-
 
-    mod iterables {
 
-
 
-        // TODO @Jon
 
-        // Set this up so instead of the view trait, we can just take functions
 
-        // Functions with no context should just be rendered
 
-        // But functions with a context should be treated as regular components
 
-
 
-        // impl<V: View> From<Vec<V>> for IterableNodes {
 
-        //     fn from(other: Vec<V>) -> Self {
 
-        //         IterableNodes(other.into_iter().map(|it| it.render()).collect())
 
-        //     }
 
-        // }
 
-
 
-        // impl<V: View> From<&Vec<V>> for IterableNodes {
 
-        //     fn from(other: &Vec<V>) -> Self {
 
-        //         IterableNodes(other.iter().map(|it| it.render()).collect())
 
-        //     }
 
-        // }
 
-
 
-        // impl<V: View> From<&[V]> for IterableNodes {
 
-        //     fn from(other: &[V]) -> Self {
 
-        //         IterableNodes(other.iter().map(|it| it.render()).collect())
 
-        //     }
 
-        // }
 
-
 
-        impl From<&str> for IterableNodes {
 
-            fn from(other: &str) -> Self {
 
-                IterableNodes(vec![VNode::text(other)])
 
-            }
 
-        }
 
-
 
-        impl From<String> for IterableNodes {
 
-            fn from(other: String) -> Self {
 
-                IterableNodes(vec![VNode::text(other.as_str())])
 
-            }
 
-        }
 
-    }
 
-
 
-    mod tests {
 
-        #[cfg(test)]
 
-        mod tests {
 
-            use super::*;
 
-
 
-            #[test]
 
-            fn self_closing_tag_to_string() {
 
-                let node = VNode::element("br");
 
-
 
-                // No </br> since self closing tag
 
-                assert_eq!(&node.to_string(), "<br>");
 
-            }
 
-
 
-            #[test]
 
-            fn to_string() {
 
-                let mut node = VNode::Element(VElement::new("div"));
 
-                node.as_velement_mut()
 
-                    .unwrap()
 
-                    .attrs
 
-                    .insert("id".into(), "some-id".into());
 
-
 
-                let mut child = VNode::Element(VElement::new("span"));
 
-
 
-                let mut text = VNode::Text(VText::new("Hello world"));
 
-
 
-                child.as_velement_mut().unwrap().children.push(text);
 
-
 
-                node.as_velement_mut().unwrap().children.push(child);
 
-
 
-                let expected = r#"<div id="some-id"><span>Hello world</span></div>"#;
 
-
 
-                assert_eq!(node.to_string(), expected);
 
-            }
 
-        }
 
-    }
 
-
 
-    mod ddiff {
 
-        /// The diffing algorithm to compare two VNode trees and generate a list of patches to update the VDom.
 
-        /// Currently, using an index-based patching algorithm
 
-        ///
 
-        pub mod diff {
 
-            use super::*;
 
-            use crate::nodes::{VNode, VText};
 
-            use std::cmp::min;
 
-            use std::collections::HashMap;
 
-            use std::mem;
 
-
 
-            // pub use apply_patches::patch;
 
-
 
-            /// A Patch encodes an operation that modifies a real DOM element.
 
-            ///
 
-            /// To update the real DOM that a user sees you'll want to first diff your
 
-            /// old virtual dom and new virtual dom.
 
-            ///
 
-            /// This diff operation will generate `Vec<Patch>` with zero or more patches that, when
 
-            /// applied to your real DOM, will make your real DOM look like your new virtual dom.
 
-            ///
 
-            /// Each Patch has a u32 node index that helps us identify the real DOM node that it applies to.
 
-            ///
 
-            /// Our old virtual dom's nodes are indexed depth first, as shown in this illustration
 
-            /// (0 being the root node, 1 being it's first child, 2 being it's first child's first child).
 
-            ///
 
-            /// ```text
 
-            ///             .─.
 
-            ///            ( 0 )
 
-            ///             `┬'
 
-            ///         ┌────┴──────┐
 
-            ///         │           │
 
-            ///         ▼           ▼
 
-            ///        .─.         .─.
 
-            ///       ( 1 )       ( 4 )
 
-            ///        `┬'         `─'
 
-            ///    ┌────┴───┐       │
 
-            ///    │        │       ├─────┬─────┐
 
-            ///    ▼        ▼       │     │     │
 
-            ///   .─.      .─.      ▼     ▼     ▼
 
-            ///  ( 2 )    ( 3 )    .─.   .─.   .─.
 
-            ///   `─'      `─'    ( 5 ) ( 6 ) ( 7 )
 
-            ///                    `─'   `─'   `─'
 
-            /// ```
 
-            ///
 
-            /// The patching process is tested in a real browser in crates/virtual-dom-rs/tests/diff_patch.rs
 
-            #[derive(PartialEq)]
 
-            pub enum Patch<'a> {
 
-                /// Append a vector of child nodes to a parent node id.
 
-                AppendChildren(NodeIdx, Vec<&'a VNode>),
 
-                /// For a `node_i32`, remove all children besides the first `len`
 
-                TruncateChildren(NodeIdx, usize),
 
-                /// Replace a node with another node. This typically happens when a node's tag changes.
 
-                /// ex: <div> becomes <span>
 
-                Replace(NodeIdx, &'a VNode),
 
-                /// Add attributes that the new node has that the old node does not
 
-                AddAttributes(NodeIdx, HashMap<&'a str, &'a str>),
 
-                /// Remove attributes that the old node had that the new node doesn't
 
-                RemoveAttributes(NodeIdx, Vec<&'a str>),
 
-                /// Change the text of a Text node.
 
-                ChangeText(NodeIdx, &'a VText),
 
-            }
 
-
 
-            type NodeIdx = usize;
 
-
 
-            impl<'a> Patch<'a> {
 
-                /// Every Patch is meant to be applied to a specific node within the DOM. Get the
 
-                /// index of the DOM node that this patch should apply to. DOM nodes are indexed
 
-                /// depth first with the root node in the tree having index 0.
 
-                pub fn node_idx(&self) -> usize {
 
-                    match self {
 
-                        Patch::AppendChildren(node_idx, _) => *node_idx,
 
-                        Patch::TruncateChildren(node_idx, _) => *node_idx,
 
-                        Patch::Replace(node_idx, _) => *node_idx,
 
-                        Patch::AddAttributes(node_idx, _) => *node_idx,
 
-                        Patch::RemoveAttributes(node_idx, _) => *node_idx,
 
-                        Patch::ChangeText(node_idx, _) => *node_idx,
 
-                    }
 
-                }
 
-            }
 
-
 
-            /// Given two VNode's generate Patch's that would turn the old virtual node's
 
-            /// real DOM node equivalent into the new VNode's real DOM node equivalent.
 
-            pub fn diff_vnodes<'a>(old: &'a VNode, new: &'a VNode) -> Vec<Patch<'a>> {
 
-                diff_recursive(&old, &new, &mut 0)
 
-            }
 
-
 
-            fn diff_recursive<'a, 'b>(
 
-                old: &'a VNode,
 
-                new: &'a VNode,
 
-                cur_node_idx: &'b mut usize,
 
-            ) -> Vec<Patch<'a>> {
 
-                let mut patches = vec![];
 
-                let mut replace = false;
 
-
 
-                // Different enum variants, replace!
 
-                // VNodes are of different types, and therefore will cause a re-render.
 
-                // TODO: Handle previously-mounted children so they don't get re-mounted
 
-                if mem::discriminant(old) != mem::discriminant(new) {
 
-                    replace = true;
 
-                }
 
-
 
-                if let (VNode::Element(old_element), VNode::Element(new_element)) = (old, new) {
 
-                    // Replace if there are different element tags
 
-                    if old_element.tag != new_element.tag {
 
-                        replace = true;
 
-                    }
 
-
 
-                    // Replace if two elements have different keys
 
-                    // TODO: More robust key support. This is just an early stopgap to allow you to force replace
 
-                    // an element... say if it's event changed. Just change the key name for now.
 
-                    // In the future we want keys to be used to create a Patch::ReOrder to re-order siblings
 
-                    if old_element.attrs.get("key").is_some()
 
-                        && old_element.attrs.get("key") != new_element.attrs.get("key")
 
-                    {
 
-                        replace = true;
 
-                    }
 
-                }
 
-
 
-                // Handle replacing of a node
 
-                if replace {
 
-                    patches.push(Patch::Replace(*cur_node_idx, &new));
 
-                    if let VNode::Element(old_element_node) = old {
 
-                        for child in old_element_node.children.iter() {
 
-                            increment_node_idx_for_children(child, cur_node_idx);
 
-                        }
 
-                    }
 
-                    return patches;
 
-                }
 
-
 
-                // The following comparison can only contain identical variants, other
 
-                // cases have already been handled above by comparing variant
 
-                // discriminants.
 
-                match (old, new) {
 
-                    // We're comparing two text nodes
 
-                    (VNode::Text(old_text), VNode::Text(new_text)) => {
 
-                        if old_text != new_text {
 
-                            patches.push(Patch::ChangeText(*cur_node_idx, &new_text));
 
-                        }
 
-                    }
 
-
 
-                    // We're comparing two element nodes
 
-                    (VNode::Element(old_element), VNode::Element(new_element)) => {
 
-                        let mut add_attributes: HashMap<&str, &str> = HashMap::new();
 
-                        let mut remove_attributes: Vec<&str> = vec![];
 
-
 
-                        // TODO: -> split out into func
 
-                        for (new_attr_name, new_attr_val) in new_element.attrs.iter() {
 
-                            match old_element.attrs.get(new_attr_name) {
 
-                                Some(ref old_attr_val) => {
 
-                                    if old_attr_val != &new_attr_val {
 
-                                        add_attributes.insert(new_attr_name, new_attr_val);
 
-                                    }
 
-                                }
 
-                                None => {
 
-                                    add_attributes.insert(new_attr_name, new_attr_val);
 
-                                }
 
-                            };
 
-                        }
 
-
 
-                        // TODO: -> split out into func
 
-                        for (old_attr_name, old_attr_val) in old_element.attrs.iter() {
 
-                            if add_attributes.get(&old_attr_name[..]).is_some() {
 
-                                continue;
 
-                            };
 
-
 
-                            match new_element.attrs.get(old_attr_name) {
 
-                                Some(ref new_attr_val) => {
 
-                                    if new_attr_val != &old_attr_val {
 
-                                        remove_attributes.push(old_attr_name);
 
-                                    }
 
-                                }
 
-                                None => {
 
-                                    remove_attributes.push(old_attr_name);
 
-                                }
 
-                            };
 
-                        }
 
-
 
-                        if add_attributes.len() > 0 {
 
-                            patches.push(Patch::AddAttributes(*cur_node_idx, add_attributes));
 
-                        }
 
-                        if remove_attributes.len() > 0 {
 
-                            patches.push(Patch::RemoveAttributes(*cur_node_idx, remove_attributes));
 
-                        }
 
-
 
-                        let old_child_count = old_element.children.len();
 
-                        let new_child_count = new_element.children.len();
 
-
 
-                        if new_child_count > old_child_count {
 
-                            let append_patch: Vec<&'a VNode> =
 
-                                new_element.children[old_child_count..].iter().collect();
 
-                            patches.push(Patch::AppendChildren(*cur_node_idx, append_patch))
 
-                        }
 
-
 
-                        if new_child_count < old_child_count {
 
-                            patches.push(Patch::TruncateChildren(*cur_node_idx, new_child_count))
 
-                        }
 
-
 
-                        let min_count = min(old_child_count, new_child_count);
 
-                        for index in 0..min_count {
 
-                            *cur_node_idx = *cur_node_idx + 1;
 
-                            let old_child = &old_element.children[index];
 
-                            let new_child = &new_element.children[index];
 
-                            patches.append(&mut diff_recursive(
 
-                                &old_child,
 
-                                &new_child,
 
-                                cur_node_idx,
 
-                            ))
 
-                        }
 
-                        if new_child_count < old_child_count {
 
-                            for child in old_element.children[min_count..].iter() {
 
-                                increment_node_idx_for_children(child, cur_node_idx);
 
-                            }
 
-                        }
 
-                    }
 
-                    (VNode::Text(_), VNode::Element(_)) | (VNode::Element(_), VNode::Text(_)) => {
 
-                        unreachable!(
 
-                            "Unequal variant discriminants should already have been handled"
 
-                        );
 
-                    }
 
-                    _ => todo!("Diffing Not yet implemented for all node types"),
 
-                };
 
-
 
-                //    new_root.create_element()
 
-                patches
 
-            }
 
-
 
-            fn increment_node_idx_for_children<'a, 'b>(
 
-                old: &'a VNode,
 
-                cur_node_idx: &'b mut usize,
 
-            ) {
 
-                *cur_node_idx += 1;
 
-                if let VNode::Element(element_node) = old {
 
-                    for child in element_node.children.iter() {
 
-                        increment_node_idx_for_children(&child, cur_node_idx);
 
-                    }
 
-                }
 
-            }
 
-
 
-            // #[cfg(test)]
 
-            // mod tests {
 
-            //     use super::*;
 
-            //     use crate::prelude::*;
 
-            //     type VirtualNode = VNode;
 
-
 
-            //     /// Test that we generate the right Vec<Patch> for some start and end virtual dom.
 
-            //     pub struct DiffTestCase<'a> {
 
-            //         // ex: "Patching root level nodes works"
 
-            //         pub description: &'static str,
 
-            //         // ex: html! { <div> </div> }
 
-            //         pub old: VNode,
 
-            //         // ex: html! { <strong> </strong> }
 
-            //         pub new: VNode,
 
-            //         // ex: vec![Patch::Replace(0, &html! { <strong></strong> })],
 
-            //         pub expected: Vec<Patch<'a>>,
 
-            //     }
 
-
 
-            //     impl<'a> DiffTestCase<'a> {
 
-            //         pub fn test(&self) {
 
-            //             // ex: vec![Patch::Replace(0, &html! { <strong></strong> })],
 
-            //             let patches = diff_vnodes(&self.old, &self.new);
 
-
 
-            //             assert_eq!(patches, self.expected, "{}", self.description);
 
-            //         }
 
-            //     }
 
-            //     use super::*;
 
-            //     use crate::nodes::{VNode, VText};
 
-            //     use std::collections::HashMap;
 
-
 
-            //     #[test]
 
-            //     fn replace_node() {
 
-            //         DiffTestCase {
 
-            //             description: "Replace the root if the tag changed",
 
-            //             old: html! { <div> </div> },
 
-            //             new: html! { <span> </span> },
 
-            //             expected: vec![Patch::Replace(0, &html! { <span></span> })],
 
-            //         }
 
-            //         .test();
 
-            //         DiffTestCase {
 
-            //             description: "Replace a child node",
 
-            //             old: html! { <div> <b></b> </div> },
 
-            //             new: html! { <div> <strong></strong> </div> },
 
-            //             expected: vec![Patch::Replace(1, &html! { <strong></strong> })],
 
-            //         }
 
-            //         .test();
 
-            //         DiffTestCase {
 
-            //             description: "Replace node with a child",
 
-            //             old: html! { <div> <b>1</b> <b></b> </div> },
 
-            //             new: html! { <div> <i>1</i> <i></i> </div>},
 
-            //             expected: vec![
 
-            //                 Patch::Replace(1, &html! { <i>1</i> }),
 
-            //                 Patch::Replace(3, &html! { <i></i> }),
 
-            //             ], //required to check correct index
 
-            //         }
 
-            //         .test();
 
-            //     }
 
-
 
-            //     #[test]
 
-            //     fn add_children() {
 
-            //         DiffTestCase {
 
-            //             description: "Added a new node to the root node",
 
-            //             old: html! { <div> <b></b> </div> },
 
-            //             new: html! { <div> <b></b> <span></span> </div> },
 
-            //             expected: vec![Patch::AppendChildren(0, vec![&html! { <span></span> }])],
 
-            //         }
 
-            //         .test();
 
-            //     }
 
-
 
-            //     #[test]
 
-            //     fn remove_nodes() {
 
-            //         DiffTestCase {
 
-            //             description: "Remove all child nodes at and after child sibling index 1",
 
-            //             old: html! { <div> <b></b> <span></span> </div> },
 
-            //             new: html! { <div> </div> },
 
-            //             expected: vec![Patch::TruncateChildren(0, 0)],
 
-            //         }
 
-            //         .test();
 
-            //         DiffTestCase {
 
-            //             description: "Remove a child and a grandchild node",
 
-            //             old: html! {
 
-            //             <div>
 
-            //              <span>
 
-            //                <b></b>
 
-            //                // This `i` tag will get removed
 
-            //                <i></i>
 
-            //              </span>
 
-            //              // This `strong` tag will get removed
 
-            //              <strong></strong>
 
-            //             </div> },
 
-            //             new: html! {
 
-            //             <div>
 
-            //              <span>
 
-            //               <b></b>
 
-            //              </span>
 
-            //             </div> },
 
-            //             expected: vec![Patch::TruncateChildren(0, 1), Patch::TruncateChildren(1, 1)],
 
-            //         }
 
-            //         .test();
 
-            //         DiffTestCase {
 
-            //             description: "Removing child and change next node after parent",
 
-            //             old: html! { <div> <b> <i></i> <i></i> </b> <b></b> </div> },
 
-            //             new: html! { <div> <b> <i></i> </b> <i></i> </div>},
 
-            //             expected: vec![
 
-            //                 Patch::TruncateChildren(1, 1),
 
-            //                 Patch::Replace(4, &html! { <i></i> }),
 
-            //             ], //required to check correct index
 
-            //         }
 
-            //         .test();
 
-            //     }
 
-
 
-            //     #[test]
 
-            //     fn add_attributes() {
 
-            //         let mut attributes = HashMap::new();
 
-            //         attributes.insert("id", "hello");
 
-
 
-            //         DiffTestCase {
 
-            //             old: html! { <div> </div> },
 
-            //             new: html! { <div id="hello"> </div> },
 
-            //             expected: vec![Patch::AddAttributes(0, attributes.clone())],
 
-            //             description: "Add attributes",
 
-            //         }
 
-            //         .test();
 
-
 
-            //         DiffTestCase {
 
-            //             old: html! { <div id="foobar"> </div> },
 
-            //             new: html! { <div id="hello"> </div> },
 
-            //             expected: vec![Patch::AddAttributes(0, attributes)],
 
-            //             description: "Change attribute",
 
-            //         }
 
-            //         .test();
 
-            //     }
 
-
 
-            //     #[test]
 
-            //     fn remove_attributes() {
 
-            //         DiffTestCase {
 
-            //             old: html! { <div id="hey-there"></div> },
 
-            //             new: html! { <div> </div> },
 
-            //             expected: vec![Patch::RemoveAttributes(0, vec!["id"])],
 
-            //             description: "Add attributes",
 
-            //         }
 
-            //         .test();
 
-            //     }
 
-
 
-            //     #[test]
 
-            //     fn change_attribute() {
 
-            //         let mut attributes = HashMap::new();
 
-            //         attributes.insert("id", "changed");
 
-
 
-            //         DiffTestCase {
 
-            //             description: "Add attributes",
 
-            //             old: html! { <div id="hey-there"></div> },
 
-            //             new: html! { <div id="changed"> </div> },
 
-            //             expected: vec![Patch::AddAttributes(0, attributes)],
 
-            //         }
 
-            //         .test();
 
-            //     }
 
-
 
-            //     #[test]
 
-            //     fn replace_text_node() {
 
-            //         DiffTestCase {
 
-            //             description: "Replace text node",
 
-            //             old: html! { Old },
 
-            //             new: html! { New },
 
-            //             expected: vec![Patch::ChangeText(0, &VText::new("New"))],
 
-            //         }
 
-            //         .test();
 
-            //     }
 
-
 
-            //     // Initially motivated by having two elements where all that changed was an event listener
 
-            //     // because right now we don't patch event listeners. So.. until we have a solution
 
-            //     // for that we can just give them different keys to force a replace.
 
-            //     #[test]
 
-            //     fn replace_if_different_keys() {
 
-            //         DiffTestCase {
 
-            //             description: "If two nodes have different keys always generate a full replace.",
 
-            //             old: html! { <div key="1"> </div> },
 
-            //             new: html! { <div key="2"> </div> },
 
-            //             expected: vec![Patch::Replace(0, &html! {<div key="2"> </div>})],
 
-            //         }
 
-            //         .test()
 
-            //     }
 
-
 
-            //     //    // TODO: Key support
 
-            //     //    #[test]
 
-            //     //    fn reorder_chldren() {
 
-            //     //        let mut attributes = HashMap::new();
 
-            //     //        attributes.insert("class", "foo");
 
-            //     //
 
-            //     //        let old_children = vec![
 
-            //     //            // old node 0
 
-            //     //            html! { <div key="hello", id="same-id", style="",></div> },
 
-            //     //            // removed
 
-            //     //            html! { <div key="gets-removed",> { "This node gets removed"} </div>},
 
-            //     //            // old node 2
 
-            //     //            html! { <div key="world", class="changed-class",></div>},
 
-            //     //            // removed
 
-            //     //            html! { <div key="this-got-removed",> { "This node gets removed"} </div>},
 
-            //     //        ];
 
-            //     //
 
-            //     //        let new_children = vec![
 
-            //     //            html! { <div key="world", class="foo",></div> },
 
-            //     //            html! { <div key="new",> </div>},
 
-            //     //            html! { <div key="hello", id="same-id",></div>},
 
-            //     //        ];
 
-            //     //
 
-            //     //        test(DiffTestCase {
 
-            //     //            old: html! { <div> { old_children } </div> },
 
-            //     //            new: html! { <div> { new_children } </div> },
 
-            //     //            expected: vec![
 
-            //     //                // TODO: Come up with the patch structure for keyed nodes..
 
-            //     //                // keying should only work if all children have keys..
 
-            //     //            ],
 
-            //     //            description: "Add attributes",
 
-            //     //        })
 
-            //     //    }
 
-            // }
 
-        }
 
-    }
 
-
 
-    mod vcomponent {
 
-        // -----------------------------------------------
 
-        //  Allow debug/display adherent to the HTML spec
 
-        // -----------------------------------------------
 
-
 
-        impl fmt::Debug for VComponent {
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                // TODO: @JON Implement how components should be formatted when spit out to html
 
-                // It probably can't be as straightforward as renderinng their VNodes
 
-                // It _could_ be, but we can't really implement that directly
 
-                // Instead, we should drop a vnode labeled with the component id/key
 
-
 
-                // write!(
 
-                //     f,
 
-                //     "Element(<{}>, attrs: {:?}, children: {:?})",
 
-                //     self.tag, self.attrs, self.children,
 
-                // )
 
-                Ok(())
 
-            }
 
-        }
 
-
 
-        impl fmt::Display for VComponent {
 
-            // Turn a VElement and all of it's children (recursively) into an HTML string
 
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
-                // write!(f, "<{}", self.tag).unwrap();
 
-
 
-                // for (attr, value) in self.attrs.iter() {
 
-                //     write!(f, r#" {}="{}""#, attr, value)?;
 
-                // }
 
-
 
-                // write!(f, ">")?;
 
-
 
-                // for child in self.children.iter() {
 
-                //     write!(f, "{}", child.to_string())?;
 
-                // }
 
-
 
-                // if !crate::validation::is_self_closing(&self.tag) {
 
-                //     write!(f, "</{}>", self.tag)?;
 
-                // }
 
-
 
-                Ok(())
 
-            }
 
-        }
 
-    }
 
-}
 
-
 
-// pub mod iterables {
 
-//     use super::*;
 
-
 
-//     /// Used by the html! macro for all braced child nodes so that we can use any type
 
-//     /// that implements Into<IterableNodes>
 
-//     ///
 
-//     /// html! { <div> { nodes } </div> }
 
-//     ///
 
-//     /// nodes can be a String .. VNode .. Vec<VNode> ... etc
 
-//     pub struct IterableNodes(Vec<VNode>);
 
-
 
-//     impl IterableNodes {
 
-//         /// Retrieve the first node mutably
 
-//         pub fn first(&mut self) -> &mut VNode {
 
-//             self.0.first_mut().unwrap()
 
-//         }
 
-
 
-//         /// Retrieve the last node mutably
 
-//         pub fn last(&mut self) -> &mut VNode {
 
-//             self.0.last_mut().unwrap()
 
-//         }
 
-//     }
 
-
 
-//     impl IntoIterator for IterableNodes {
 
-//         type Item = VNode;
 
-//         // TODO: Is this possible with an array [VNode] instead of a vec?
 
-//         type IntoIter = ::std::vec::IntoIter<VNode>;
 
-
 
-//         fn into_iter(self) -> Self::IntoIter {
 
-//             self.0.into_iter()
 
-//         }
 
-//     }
 
-
 
-//     impl From<VNode> for IterableNodes {
 
-//         fn from(other: VNode) -> Self {
 
-//             IterableNodes(vec![other])
 
-//         }
 
-//     }
 
-
 
-//     impl From<Vec<VNode>> for IterableNodes {
 
-//         fn from(other: Vec<VNode>) -> Self {
 
-//             IterableNodes(other)
 
-//         }
 
-//     }
 
-// }

+ 0 - 80
packages/core/old/patch.rs
查看文件 

@@ -1,80 +0,0 @@
 
-use fxhash::FxHashMap;
 
-
 
-use crate::innerlude::{VNode, VText};
 
-
 
-/// A Patch encodes an operation that modifies a real DOM element.
 
-///
 
-/// To update the real DOM that a user sees you'll want to first diff your
 
-/// old virtual dom and new virtual dom.
 
-///
 
-/// This diff operation will generate `Vec<Patch>` with zero or more patches that, when
 
-/// applied to your real DOM, will make your real DOM look like your new virtual dom.
 
-///
 
-/// Each Patch has a u32 node index that helps us identify the real DOM node that it applies to.
 
-///
 
-/// Our old virtual dom's nodes are indexed depth first, as shown in this illustration
 
-/// (0 being the root node, 1 being it's first child, 2 being it's first child's first child).
 
-///
 
-/// ```text
 
-///             .─.
 
-///            ( 0 )
 
-///             `┬'
 
-///         ┌────┴──────┐
 
-///         │           │
 
-///         ▼           ▼
 
-///        .─.         .─.
 
-///       ( 1 )       ( 4 )
 
-///        `┬'         `─'
 
-///    ┌────┴───┐       ├─────┬─────┐
 
-///    │        │       │     │     │
 
-///    ▼        ▼       ▼     ▼     ▼
 
-///   .─.      .─.     .─.   .─.   .─.
 
-///  ( 2 )    ( 3 )   ( 5 ) ( 6 ) ( 7 )
 
-///   `─'      `─'     `─'   `─'   `─'                  
-/// ```
 
-///
 
-/// The patching process is tested in a real browser in crates/virtual-dom-rs/tests/diff_patch.rs
 
-
 
-// #[derive(serde::Serialize, serde::Deserialize)]
 
-pub enum Patch<'a> {
 
-    /// Append a vector of child nodes to a parent node id.
 
-    AppendChildren(NodeIdx, Vec<&'a VNode<'a>>),
 
-
 
-    /// For a `node_i32`, remove all children besides the first `len`
 
-    TruncateChildren(NodeIdx, usize),
 
-
 
-    /// Replace a node with another node. This typically happens when a node's tag changes.
 
-    /// ex: <div> becomes <span>
 
-    Replace(NodeIdx, &'a VNode<'a>),
 
-
 
-    /// Add attributes that the new node has that the old node does not
 
-    AddAttributes(NodeIdx, FxHashMap<&'a str, &'a str>),
 
-
 
-    /// Remove attributes that the old node had that the new node doesn't
 
-    RemoveAttributes(NodeIdx, Vec<&'a str>),
 
-
 
-    /// Change the text of a Text node.
 
-    ChangeText(NodeIdx, &'a VText<'a>),
 
-}
 
-
 
-type NodeIdx = usize;
 
-
 
-impl<'a> Patch<'a> {
 
-    /// Every Patch is meant to be applied to a specific node within the DOM. Get the
 
-    /// index of the DOM node that this patch should apply to. DOM nodes are indexed
 
-    /// depth first with the root node in the tree having index 0.
 
-    pub fn node_idx(&self) -> usize {
 
-        match self {
 
-            Patch::AppendChildren(node_idx, _) => *node_idx,
 
-            Patch::TruncateChildren(node_idx, _) => *node_idx,
 
-            Patch::Replace(node_idx, _) => *node_idx,
 
-            Patch::AddAttributes(node_idx, _) => *node_idx,
 
-            Patch::RemoveAttributes(node_idx, _) => *node_idx,
 
-            Patch::ChangeText(node_idx, _) => *node_idx,
 
-        }
 
-    }
 
-}
 
-
 
-pub struct PatchList<'a> {
 
-    patches: Vec<Patch<'a>>,
 
-}

+ 0 - 329
packages/core/old/percydiff.rs
查看文件 

@@ -1,329 +0,0 @@
 
-//! A primitive diffing algorithm
 
-//!
 
-//!
 
-//!
 
-//!
 
-//!
 
-
 
-use std::{collections::HashMap, mem};
 
-
 
-use crate::innerlude::*;
 
-use crate::patch::Patch;
 
-use fxhash::{FxBuildHasher, FxHashMap, FxHashSet};
 
-use generational_arena::Index;
 
-
 
-pub struct DiffMachine {
 
-    immediate_queue: Vec<Index>,
 
-    diffed: FxHashSet<Index>,
 
-    need_to_diff: FxHashSet<Index>,
 
-    marked_for_removal: Vec<Index>,
 
-}
 
-
 
-impl DiffMachine {
 
-    pub fn new() -> Self {
 
-        Self {
 
-            immediate_queue: vec![],
 
-            diffed: FxHashSet::default(),
 
-            need_to_diff: FxHashSet::default(),
 
-            marked_for_removal: vec![],
 
-        }
 
-    }
 
-
 
-    /// Given two VirtualNode's generate Patch's that would turn the old virtual node's
 
-    /// real DOM node equivalent into the new VirtualNode's real DOM node equivalent.
 
-    pub fn diff<'a>(&mut self, old: &'a VNode, new: &'a VNode) -> Vec<Patch<'a>> {
 
-        self.diff_recursive(&old, &new, &mut 0)
 
-    }
 
-
 
-    pub fn diff_recursive<'a, 'b>(
 
-        &mut self,
 
-        old: &'a VNode,
 
-        new: &'a VNode,
 
-        cur_node_idx: &'b mut usize,
 
-    ) -> Vec<Patch<'a>> {
 
-        let mut patches = vec![];
 
-        let mut replace = false;
 
-
 
-        // Different enum variants, replace!
 
-        if mem::discriminant(old) != mem::discriminant(new) {
 
-            replace = true;
 
-        }
 
-
 
-        if let (VNode::Element(old_element), VNode::Element(new_element)) = (old, new) {
 
-            // Replace if there are different element tags
 
-            if old_element.tag_name != new_element.tag_name {
 
-                // if old_element.tag != new_element.tag {
 
-                replace = true;
 
-            }
 
-
 
-            // Replace if two elements have different keys
 
-            // TODO: More robust key support. This is just an early stopgap to allow you to force replace
 
-            // an element... say if it's event changed. Just change the key name for now.
 
-            // In the future we want keys to be used to create a Patch::ReOrder to re-order siblings
 
-            // todo!
 
-            // if old_element.attributes.get("key").is_some()
 
-            //     && old_element.attrs.get("key") != new_element.attrs.get("key")
 
-            // {
 
-            //     replace = true;
 
-            // }
 
-        }
 
-
 
-        // Handle replacing of a node
 
-        if replace {
 
-            patches.push(Patch::Replace(*cur_node_idx, &new));
 
-            if let VNode::Element(old_element_node) = old {
 
-                for child in old_element_node.children.iter() {
 
-                    increment_node_idx_for_children(child, cur_node_idx);
 
-                }
 
-            }
 
-            return patches;
 
-        }
 
-
 
-        // The following comparison can only contain identical variants, other
 
-        // cases have already been handled above by comparing variant
 
-        // discriminants.
 
-        match (old, new) {
 
-            // We're comparing two text nodes
 
-            (VNode::Text(old_text), VNode::Text(new_text)) => {
 
-                if old_text != new_text {
 
-                    patches.push(Patch::ChangeText(*cur_node_idx, &new_text));
 
-                }
 
-            }
 
-
 
-            // We're comparing two element nodes
 
-            (VNode::Element(old_element), VNode::Element(new_element)) => {
 
-                // let b: HashMap<&str, &str, FxBuildHasher>  = HashMap::new()
 
-                let old_attrs = old_element
 
-                    .attributes
 
-                    .iter()
 
-                    .map(|f| (f.name, f.value))
 
-                    .collect::<HashMap<&'static str, &str, FxBuildHasher>>();
 
-
 
-                let new_attrs = old_element
 
-                    .attributes
 
-                    .iter()
 
-                    .map(|f| (f.name, f.value))
 
-                    .collect::<HashMap<&'static str, &str, FxBuildHasher>>();
 
-
 
-                let mut add_attributes = FxHashMap::<&'static str, &str>::default();
 
-                // [("blah", "blah")]
 
-                // .into_iter()
 
-                // .map(|f| (f.0, f.1))
 
-                // .collect::<HashMap<&'static str, &str, FxBuildHasher>>();
 
-
 
-                // let mut add_attribute = HashMap::<&str, &str, FxBuildHasher>::new();
 
-                let mut remove_attributes: Vec<&str> = vec![];
 
-
 
-                // TODO: -> split out into func
 
-                for (new_attr_name, new_attr_val) in new_attrs.iter() {
 
-                    // for (new_attr_name, new_attr_val) in new_element.attrs.iter() {
 
-                    match old_attrs.get(new_attr_name) {
 
-                        // match old_element.attrs.get(new_attr_name) {
 
-                        Some(ref old_attr_val) => {
 
-                            if old_attr_val != &new_attr_val {
 
-                                add_attributes.insert(new_attr_name, new_attr_val);
 
-                            }
 
-                        }
 
-                        None => {
 
-                            add_attributes.insert(new_attr_name, new_attr_val);
 
-                        }
 
-                    };
 
-                }
 
-
 
-                // TODO: -> split out into func
 
-                for (old_attr_name, old_attr_val) in old_attrs.iter() {
 
-                    // for (old_attr_name, old_attr_val) in old_element.attrs.iter() {
 
-                    if add_attributes.get(&old_attr_name[..]).is_some() {
 
-                        continue;
 
-                    };
 
-
 
-                    match new_attrs.get(old_attr_name) {
 
-                        // match new_element.attrs.get(old_attr_name) {
 
-                        Some(ref new_attr_val) => {
 
-                            if new_attr_val != &old_attr_val {
 
-                                remove_attributes.push(old_attr_name);
 
-                            }
 
-                        }
 
-                        None => {
 
-                            remove_attributes.push(old_attr_name);
 
-                        }
 
-                    };
 
-                }
 
-
 
-                if add_attributes.len() > 0 {
 
-                    patches.push(Patch::AddAttributes(*cur_node_idx, add_attributes));
 
-                }
 
-                if remove_attributes.len() > 0 {
 
-                    patches.push(Patch::RemoveAttributes(*cur_node_idx, remove_attributes));
 
-                }
 
-
 
-                let old_child_count = old_element.children.len();
 
-                let new_child_count = new_element.children.len();
 
-
 
-                if new_child_count > old_child_count {
 
-                    let append_patch: Vec<&'a VNode> =
 
-                        new_element.children[old_child_count..].iter().collect();
 
-                    patches.push(Patch::AppendChildren(*cur_node_idx, append_patch))
 
-                }
 
-
 
-                if new_child_count < old_child_count {
 
-                    patches.push(Patch::TruncateChildren(*cur_node_idx, new_child_count))
 
-                }
 
-
 
-                let min_count = std::cmp::min(old_child_count, new_child_count);
 
-                for index in 0..min_count {
 
-                    *cur_node_idx = *cur_node_idx + 1;
 
-                    let old_child = &old_element.children[index];
 
-                    let new_child = &new_element.children[index];
 
-                    patches.append(&mut self.diff_recursive(&old_child, &new_child, cur_node_idx))
 
-                }
 
-                if new_child_count < old_child_count {
 
-                    for child in old_element.children[min_count..].iter() {
 
-                        increment_node_idx_for_children(child, cur_node_idx);
 
-                    }
 
-                }
 
-            }
 
-
 
-            (VNode::Suspended, _)
 
-            | (_, VNode::Suspended)
 
-            | (VNode::Component(_), _)
 
-            | (_, VNode::Component(_)) => {
 
-                todo!("cant yet handle these two")
 
-            }
 
-
 
-            (VNode::Text(_), VNode::Element(_))
 
-            | (VirtualNode::Element(_), VirtualNode::Text(_)) => {
 
-                unreachable!("Unequal variant discriminants should already have been handled");
 
-            }
 
-        };
 
-
 
-        //    new_root.create_element()
 
-        patches
 
-    }
 
-}
 
-
 
-fn increment_node_idx_for_children<'a, 'b>(old: &'a VirtualNode, cur_node_idx: &'b mut usize) {
 
-    *cur_node_idx += 1;
 
-    if let VirtualNode::Element(element_node) = old {
 
-        for child in element_node.children.iter() {
 
-            increment_node_idx_for_children(&child, cur_node_idx);
 
-        }
 
-    }
 
-}
 
-
 
-// #[cfg(test)]
 
-mod tests {
 
-    use bumpalo::Bump;
 
-
 
-    use super::*;
 
-
 
-    fn test_diff(
 
-        tree1: impl Fn(&Bump) -> VNode<'_>,
 
-        tree2: impl Fn(&Bump) -> VNode<'_>,
 
-        expected_patches: Vec<Patch>,
 
-        description: &'static str,
 
-    ) {
 
-        let bump = Bump::new();
 
-
 
-        let nodes1 = tree1(&bump);
 
-        let nodes2 = tree1(&bump);
 
-
 
-        let mut machine = DiffMachine::new();
 
-
 
-        let patches = machine.diff(&nodes1, &nodes2);
 
-
 
-        patches
 
-            .iter()
 
-            .zip(expected_patches.iter())
 
-            .for_each(|f| assert_eq!(compare_patch(f.0, f.1), true, "{}", description));
 
-    }
 
-
 
-    // todo: make this actually perform real comparisons
 
-    // by default, nothing is derived for vnodes or patches
 
-    fn compare_patch(patch1: &Patch, patch2: &Patch) -> bool {
 
-        match (patch1, patch2) {
 
-            (Patch::AppendChildren(_, _), Patch::AppendChildren(_, _)) => true,
 
-            (Patch::AppendChildren(_, _), _) => false,
 
-
 
-            (Patch::TruncateChildren(_, _), Patch::TruncateChildren(_, _)) => true,
 
-            (Patch::TruncateChildren(_, _), _) => false,
 
-
 
-            (Patch::Replace(_, _), Patch::Replace(_, _)) => true,
 
-            (Patch::Replace(_, _), _) => false,
 
-
 
-            (Patch::AddAttributes(_, _), Patch::AddAttributes(_, _)) => true,
 
-            (Patch::AddAttributes(_, _), _) => false,
 
-
 
-            (Patch::RemoveAttributes(_, _), Patch::RemoveAttributes(_, _)) => true,
 
-            (Patch::RemoveAttributes(_, _), _) => false,
 
-
 
-            (Patch::ChangeText(_, _), Patch::ChangeText(_, _)) => true,
 
-            (Patch::ChangeText(_, _), _) => false,
 
-        }
 
-    }
 
-
 
-    fn printdiff(
 
-        tree1: impl for<'a> Fn(&'a Bump) -> VNode<'a>,
 
-        tree2: impl for<'a> Fn(&'a Bump) -> VNode<'a>,
 
-        desc: &'static str,
 
-    ) {
 
-        let bump = Bump::new();
 
-
 
-        let nodes1 = tree1(&bump);
 
-        let nodes2 = tree2(&bump);
 
-
 
-        let mut machine = DiffMachine::new();
 
-
 
-        let patches = machine.diff(&nodes1, &nodes2);
 
-
 
-        patches.iter().for_each(|f| match f {
 
-            Patch::AppendChildren(idx, a) => {
 
-                println!("AppendChildren");
 
-            }
 
-            Patch::TruncateChildren(idx, a) => {
 
-                println!("TruncateChildren");
 
-            }
 
-            Patch::Replace(idx, a) => {
 
-                println!("Replace");
 
-            }
 
-            Patch::AddAttributes(idx, a) => {
 
-                println!("AddAttributes");
 
-            }
 
-            Patch::RemoveAttributes(idx, a) => {
 
-                println!("RemoveAttributes");
 
-            }
 
-            Patch::ChangeText(idx, a) => {
 
-                println!("ChangeText");
 
-            }
 
-        });
 
-    }
 
-
 
-    #[test]
 
-    fn example_diff() {
 
-        printdiff(
 
-            html! { <div> </div> },
 
-            html! { <div>"Hello world!" </div> },
 
-            "demo the difference between two simple dom tree",
 
-        );
 
-
 
-        printdiff(
 
-            html! {
 
-                <div>
 
-                    "Hello world!"
 
-                </div>
 
-            },
 
-            html! {
 
-                <div>
 
-                    <div>
 
-                        "Hello world!"
 
-                        "Hello world!"
 
-                        "Hello world!"
 
-                        "Hello world!"
 
-                        "Hello world!"
 
-                    </div>
 
-                </div>
 
-            },
 
-            "demo the difference between two simple dom tree",
 
-        );
 
-    }
 
-}

+ 0 - 40
packages/core/old/validation.rs
查看文件 

@@ -1,40 +0,0 @@
 
-/// TODO @Jon
 
-/// Figure out if validation should be its own crate, or embedded directly into dioxus
 
-///
 
-/// Should we even be bothered with validation?
 
-///
 
-///
 
-///
 
-mod validation {
 
-    use once_cell::sync::Lazy;
 
-    use std::collections::HashSet;
 
-
 
-    // Used to uniquely identify elements that contain closures so that the DomUpdater can
 
-    // look them up by their unique id.
 
-    // When the DomUpdater sees that the element no longer exists it will drop all of it's
 
-    // Rc'd Closures for those events.
 
-    // It doesn't quite make sense to keep this here, perhaps just in the html crate?
 
-    // Dioxus itself shouldn't be concerned with the attribute names
 
-    // a ftk!
 
-    static SELF_CLOSING_TAGS: Lazy<HashSet<&'static str>> = Lazy::new(|| {
 
-        [
 
-            "area", "base", "br", "col", "hr", "img", "input", "link", "meta", "param", "command",
 
-            "keygen", "source",
 
-        ]
 
-        .iter()
 
-        .cloned()
 
-        .collect()
 
-    });
 
-
 
-    /// Whether or not this tag is self closing
 
-    ///
 
-    /// ```ignore
 
-    /// use dioxus_core::validation::is_self_closing;
 
-    /// assert_eq!(is_self_closing("br"), true);
 
-    /// assert_eq!(is_self_closing("div"), false);
 
-    /// ```
 
-    pub fn is_self_closing(tag: &str) -> bool {
 
-        SELF_CLOSING_TAGS.contains(tag)
 
-        // SELF_CLOSING_TAGS.contains(tag) || is_self_closing_svg_tag(tag)
 
-    }
 
-}

+ 0 - 0
packages/core/old/virtual_node.rs
查看文件


+ 1 - 1
packages/core/src/virtual_dom.rs
查看文件 

@@ -41,7 +41,7 @@ pub struct VirtualDom {
 
     ///
 
     ///
 
     /// This is wrapped in an UnsafeCell because we will need to get mutable access to unique values in unique bump arenas
 
     /// This is wrapped in an UnsafeCell because we will need to get mutable access to unique values in unique bump arenas
 
     /// and rusts's guartnees cannot prove that this is safe. We will need to maintain the safety guarantees manually.
 
     /// and rusts's guartnees cannot prove that this is safe. We will need to maintain the safety guarantees manually.
 
-    components: ScopeArena,
 
+    pub components: ScopeArena,
 
 
 
     /// The index of the root component
 
     /// The index of the root component
 
     /// Should always be the first (gen0, id0)
 
     /// Should always be the first (gen0, id0)

+ 7 - 9
packages/ssr/src/tostring.rs
查看文件 

@@ -9,14 +9,7 @@ struct SsrRenderer {
 
 
 
 impl Display for SsrRenderer {
 
 impl Display for SsrRenderer {
 
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 
-        let node = self
 
-            .dom
 
-            .base_scope()
 
-            // .components
 
-            // .get(self.dom.base_scope)
 
-            // .unwrap()
 
-            .frames
 
-            .current_head_node();
 
+        let node = self.dom.base_scope().frames.current_head_node();
 
 
 
         html_render(&self.dom, node, f)
 
         html_render(&self.dom, node, f)
 
     }
 
     }
 
@@ -45,7 +38,12 @@ fn html_render(
 
         VNode::Suspended => todo!(),
 
         VNode::Suspended => todo!(),
 
         VNode::Component(vcomp) => {
 
         VNode::Component(vcomp) => {
 
             let id = vcomp.ass_scope.as_ref().borrow().unwrap();
 
             let id = vcomp.ass_scope.as_ref().borrow().unwrap();
 
-            let new_node = dom.components.get(id).unwrap().frames.current_head_node();
 
+            let new_node = dom
 
+                .components
 
+                .try_get(id)
 
+                .unwrap()
 
+                .frames
 
+                .current_head_node();
 
             html_render(&dom, new_node, f)
 
             html_render(&dom, new_node, f)
 
         }
 
         }
 
     }
 
     }