6be990e · reflex-dom · git.iko.soy

git.iko.soy/reflex-dom

Make the 'delete*' functions in Reflex.Dom.Builder.Immediate reparent nodes to a new DocumentFragment so that they aren't parentless

6be990eRyan Trinkle10 years ago

reflex-dom-core/src/Reflex/Dom/Builder/Immediate.hs+33−54

compare with develop

unifiedsplit

@@ -140,74 +140,53 @@ textNodeInternal t = do

140 append n

141 return n

142

143−-- | s and e must both be children of the same node and s must precede e;

144−-- s, e and all nodes between s and e will be removed

145−{-# INLINABLE deleteBetweenInclusive #-}

146−deleteBetweenInclusive :: (MonadJSM m, IsNode start, IsNode end) => start -> end -> m ()

147−deleteBetweenInclusive s e = liftJSM $ do

148− f <- eval $ T.unlines

149− [ "(function(s,e){"

150− , " p = e.parentNode;"

151− , " if(p !== null) {"

152− , " for(;;){"

153− , " x = e.previousSibling;"

154− , " p.removeChild(x);"

155− , " if(s===x) break;"

156− , " }"

157− , " p.removeChild(e);"

158− , " }"

159− , "})"

160− ]

161− void $ call f f (s, e)

162−

163-- | s and e must both be children of the same node and s must precede e;

143-- | s and e must both be children of the same node and s must precede e;

164-- all nodes between s and e will be removed, but s and e will not be removed

144-- all nodes between s and e will be removed, but s and e will not be removed

165deleteBetweenExclusive :: (MonadJSM m, IsNode start, IsNode end) => start -> end -> m ()

145deleteBetweenExclusive :: (MonadJSM m, IsNode start, IsNode end) => start -> end -> m ()

166deleteBetweenExclusive s e = liftJSM $ do

146deleteBetweenExclusive s e = liftJSM $ do

147+ df <- createDocumentFragmentUnchecked =<< getOwnerDocumentUnchecked s

148+ extractBetweenExclusive df s e -- In many places in ImmediateDomBuilderT, we assume that things always have a parent; by adding them to this DocumentFragment, we maintain that invariant

149+

150+-- | s and e must both be children of the same node and s must precede e; all

151+-- nodes between s and e will be moved into the given DocumentFragment, but s

152+-- and e will not be moved

153+extractBetweenExclusive :: (MonadJSM m, IsNode start, IsNode end) => DOM.DocumentFragment -> start -> end -> m ()

154+extractBetweenExclusive df s e = liftJSM $ do

167 f <- eval $ T.unlines

155 f <- eval $ T.unlines

168− [ "(function(s,e){"

156+ [ "(function(df,s,e){"

169− , " p = e.parentNode;"

157+ , " var x;"

170− , " if(p !== null) {"

171− , " for(;;){"

158+ , " for(;;){"

172− , " x = e.previousSibling;"

159+ , " x = s.nextSibling;"

173− , " if(s===x) break;"

160+ , " if(e===x) break;"

174− , " p.removeChild(x);"

161+ , " df.appendChild(x);"

175− , " }"

162+ , " }"

176− , " }})"

163+ , "})"

177 ]

164 ]

178− void $ call f f (s, e)

165+ void $ call f f (df, s, e)

179

166

180-- | s and e must both be children of the same node and s must precede e;

167-- | s and e must both be children of the same node and s must precede e;

181-- s and all nodes between s and e will be removed, but e will not be removed

168-- s and all nodes between s and e will be removed, but e will not be removed

182{-# INLINABLE deleteUpTo #-}

169{-# INLINABLE deleteUpTo #-}

183deleteUpTo :: (MonadJSM m, IsNode start, IsNode end) => start -> end -> m ()

170deleteUpTo :: (MonadJSM m, IsNode start, IsNode end) => start -> end -> m ()

184−deleteUpTo s e = liftJSM $ do

171+deleteUpTo s e = do

185− f <- eval $ T.unlines

172+ df <- createDocumentFragmentUnchecked =<< getOwnerDocumentUnchecked s

186− [ "(function(s,e){"

173+ extractUpTo df s e -- In many places in ImmediateDomBuilderT, we assume that things always have a parent; by adding them to this DocumentFragment, we maintain that invariant

187− , " p = e.parentNode;"

188− , " if(p !== null) {"

189− , " for(;;) {"

190− , " x = e.previousSibling;"

191− , " p.removeChild(x);"

192− , " if(s===x) break;"

193− , " }"

194− , " }})"

195− ]

196− void $ call f f (s, e)

197

174

198−-- | s and all nodes between s and e will be removed, but e will not be removed

199−{-# INLINABLE deleteUpToGivenParent #-}

200−deleteUpToGivenParent :: (MonadJSM m, IsNode parent, IsNode start, IsNode end) => parent -> start -> end -> m ()

175+extractUpTo :: (MonadJSM m, IsNode start, IsNode end) => DOM.DocumentFragment -> start -> end -> m ()

201−deleteUpToGivenParent currentParent s e = liftJSM $ do

176+extractUpTo df s e = liftJSM $ do

202 f <- eval $ T.unlines

177 f <- eval $ T.unlines

203− [ "(function(p,s,e){"

178+ [ "(function(df,s,e){"

179+ , " var x = s;"

180+ , " var y;"

204− , " for(;;){"

181+ , " for(;;) {"

205− , " x = e.previousSibling;"

182+ , " y = x.nextSibling;"

206− , " p.removeChild(x);"

183+ , " df.appendChild(x);"

207− , " if(s===x) break;"

184+ , " if(e===y) break;"

185+ , " x = y;"

186+ , " }"

208− , " }})"

187+ , "})"

209 ]

188 ]

210− void $ call f f (currentParent, s, e)

189+ void $ call f f (df, s, e)

211

190

212type SupportsImmediateDomBuilder t m = (Reflex t, MonadJSM m, MonadJSM (Performable m), MonadHold t m, MonadFix m, PerformEvent t m, MonadReflexCreateTrigger t m, MonadRef m, Ref m ~ Ref JSM, MonadAdjust t m)

191type SupportsImmediateDomBuilder t m = (Reflex t, MonadJSM m, MonadJSM (Performable m), MonadHold t m, MonadFix m, PerformEvent t m, MonadReflexCreateTrigger t m, MonadRef m, Ref m ~ Ref JSM, MonadAdjust t m)

213

192