!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None.Using a React Element (first arg) give React rendering control over a DOM element (second arg). This should only be called for the topmost component.None .59:;<=?DR A record of Scene and Frame. PFrame is a Mvar of Scene. React rendering callback uses this MVar for rendering. A record of Model and Plan?Convert to the pure serializable model for saving and restoring/Lens to the pure model for state and rendering.1Lens to the callbacks and interactions with React6A Gizmo can be converted to Outline by using the ModelVUndecidableinstances! But this is safe because Scene is definitely smaller than Gizmo6A Scene can be converted to Outline by using the Model!KAll scenes should be disposable to make it easier for cleanup of callbacks."  !" "  "!      !"None !.9;<=DR_%Keyboard events %( must only be used in the first part of ..  Ahttps://facebook.github.io/react/docs/events.html#keyboard-eventsT Event names (eventType) onKeyDown (keydown) onKeyPress (keypress) onKeyUp (keyyp)'Mouse and Drag/Drop events '( must only be used in the first part of ..  >https://facebook.github.io/react/docs/events.html#mouse-events  3https://developer.mozilla.org/en-US/docs/Web/Events Event names (eventType) onClick (click) onContextMenu (contextmenu) onDoubleClick (dblclick) onDrag (drag) onDragEnd (dragend) onDragEnter (dragenter) onDragExit (dragexit) onDragLeave (dragleave) onDragOver (dragover) onDragStart (dragstart) onDrop (drop) onMouseDown (mousedown) onMouseEnter (mouseenter) onMouseLeave (mouseleave) onMouseMove (mousemove) onMouseOut (mouseout) onMouseOver (mouseover) onMouseUp (mouseup))Every + can be parsed to an ). )( must only be used in the first part of ..+]Every event in React is a synthetic event, a cross-browser wrapper around the native event. +( must only be used in the first part of ..,The native event 6https://developer.mozilla.org/en-US/docs/Web/API/Event-'The object that dispatched the event. =https://developer.mozilla.org/en-US/docs/Web/API/Event/target. Using the NFData idea from ReactFlux/PropertiesAndEvents.hs React re-uses SyntheticEvent from a pool, which means it may no longer be valid if we lazily parse it. However, we still want lazy parsing so we don't parse unnecessary fields. Additionally, we don't want to block during the event handling.The reason this is a problem is because Javascript is single threaded, but Haskell is lazy. Therefore GHCJS threads are a strange mixture of synchronous and asynchronous threads, where a synchronous thread might be converted to an asynchronous thread if a "black hole" is encountered. See  Chttps://github.com/ghcjs/ghcjs-base/blob/master/GHCJS/Concurrent.hs This safe interface requires two input functions: 1. a function to reduce SyntheticEvent to a NFData. The mkEventCallback will ensure that the NFData is forced which will ensure all the required fields from Synthetic event has been parsed. This function must not block. 2. a second function that uses the NFData. This function is allowed to block. mkEventHandler results in a function that you can safely pass into   with ./Fa monadic version of eventHandler The monad's effects must not block!IWe can lie about this not being in IO because within the strict part of /[ the SyntheticEvent is effectively immutable. In reality SyntheticEvent is reused from a pool. We want to maintain this lie so that we can lazily parse only the properties the event handler is interested in. This will throw if J.JSVal is null, or not convertible to the desired type so we are assuming that SyntheticEvent will behave nicely.See  ;https://www.w3.org/TR/DOM-Level-3-Events-key/#keys-modifierp This will throw if J.JSVal is null, but shouldn't happen since we've already check for a valid SyntheticEvent5IWe can lie about this not being in IO because within the strict part of /. the SyntheticEvent is effectively immutable.6IWe can lie about this not being in IO because within the strict part of /. the SyntheticEvent is effectively immutable.<unsafe and non-IO to enable lazy parsing. See mkEventHandler1unsafe to enable lazy parsing. See mkEventHandlerR%&'()*+,-./0123456789:;<=>?@AB%&'()*+,-./0123456-,+./)*01234'(5%&6(% &'() *+,-./0123456789:;<=>?@ABNone.DUnfortunately, ReactJS did not export an easy way to check if something is a ReactElement, although they do so in the internal code with REACT_ELEMENT_TYPE. This function allow coercing a ReactElement from a JSVal and is marked unsafe as a reminder that the coersion is unchecked. This function is required when receiving ReactElement from javascript (eg in a callback) or to interface with foreign React Elements.ECCreate a react element (with children) from a HashMap of propertiesFFCreate a react element (with no children) from a HashMap of propertiesG.Not an IO action because JSString is immutableHqReact only allows a single top most element. Provide a handly function to wrap a list of ReactElements inside a Q if required. If there is only one element in the list, then nothing is changed.This is an IO action because even if the same args was used a different ReactElement may be created, because JSVal and JSArray are mutable.CDEFGHIJKCDEFGHCDEFGH CDEFGHIJKNone .9;<=DIR MMonadic generator of ReactActom. It is a CPS-style WriterT (ie a StateT) to build up a function build up a computations to generate a '[AtomMarkup]'. You can use  with an initial state of .UCThe parameters required to create a leaf ReactElement (no children)WEThe parameters required to create a branch ReactElement with childrenYCreate  ReactElement s from a  AtomMarkupZTo use an exisitng ReactElement[(Convert the ReactMlt to [R.ReactElement]\*Render the ReactMlt under a Glazier window]1Fully render the ReactMlt into a [R.ReactElement]^/Fully render the ReactMlt into a R.ReactElement_For text content`!For the contentless elements: eg br_a For the contentful elements: eg div_LMNOPQRSTUVWXYZ[\]^_`abcLMNOPQRSTUVWXYZ[\]^_`aPQRSTWXUVYMNOLZ[\]^_`aLMNOPQRSTUVWXYZ[\]^_`abcNone.nyA newtype wrapper to give a noop disposable instance to React components This allows generic deriving of model Adaptors.nopqrsnononopqrsNone %&.2:DOTtGDSL for IO effects required during making widget models and callbacks t$ remembers the action type to allow  mapAction for changing the action type by parent widgets. The model type does not need to be changed, so it is hidden in the GADT existential.(Allows changing the action type of Makertuvwxyz{|}~tuvwxyz|}~tuvwxyz{~}| tuvwxyz{|}~None %&.9:;<=DR This typeclass is convenient as it carries the 'Disposing Model' and 'Disposing Plan' constraints and allows treating 'Widget c a m p' as a type wMake a Model from an OutlineEGiven an empty frame, make the Plan that uses the frame for rendering8Rendering function that uses the Scene of Model and PlanCUpdate function that processes Action to update the Frame and SceneRecord of functions for a widget. Contains everything you need to make the model, render, and run the event processing. This is a GADT to enforce the Disposing and ToOutline constraints at the time of creating the Widget record.You can't use type family as a type variable for a data type. The workaround is to use a tag to choose between different type family functions. ModelType takes a tag to choose between Gizmo or Outline. This enables creating a data, type that can specialize to using the tag.0tag used to choose Schema that contains Outlines.tag used to choose Schema that contains Gizmos,Make the required Frame and Plan for a Model0Make the required Frame and Plan from an Outline None.NThis is called synchronously by React to render the DOM. This must not block! None.OT None.OTJust change the state to something different so the React pureComponent will call render() renderCmd :: Monad m => (sm -> [JE.Property] -> J.JSVal -> cmd) -> G.GadgetT act sm m cmd The resulting command should be interpreted using componentSetState !"#$%&'()*+,-./0123344556789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXXYZ[\]^__``abcdefghijklmnopqrstuvwxyz{|}~ 678Nv ,glazier-react-0.5.0.0-9ANqmC0rMHz1k8ZydfTrfeGlazier.React.ReactDOMGlazier.React.ModelGlazier.React.EventGlazier.React.ElementGlazier.React.MarkupGlazier.React.ComponentGlazier.React.MakerGlazier.React.WidgetGlazier.React.Maker.RunGlazier.React.Command.RunGlazier.React.CommandGHC.Foreign.Callback syncCallback1GHCJS.Foreign.Callback ContinueAsyncrenderHasGizmogizmoGizmo_scene_frameHasFrameframeFrameHasScenesceneScene_model_plan ToOutlineoutlineHasModelmodelHasPlanplan$fToOutlineGizmoo$fHasModelGizmomdl$fHasPlanGizmopln$fHasSceneGizmomdlpln$fHasFrameGizmomdlpln$fHasGizmoGizmomdlpln$fDisposingGizmo$fHasFrameMVarmdlpln$fToOutlineSceneol$fHasModelScenemdl$fHasPlanScenepln$fDisposingScene$fHasSceneScenemdlpln$fGenericScene$fGenericGizmo KeyboardEvent MouseEventEventSyntheticEventDOMEventDOMEventTarget eventHandler eventHandlerMpreventDefaultisDefaultPreventedstopPropagationisPropagationStopped parseEventparseMouseEventparseKeyboardEvent$fFromJSSyntheticEvent$fToJSSyntheticEvent$fPToJSValSyntheticEvent$fIsJSValSyntheticEvent$fFromJSDOMEvent$fToJSDOMEvent$fPToJSValDOMEvent$fIsJSValDOMEvent$fFromJSDOMEventTarget$fToJSDOMEventTarget$fPToJSValDOMEventTarget$fIsJSValDOMEventTarget ReactElementunsafeCoerceElementmkBranchElement mkLeafElement textElementmkCombinedElements$fToJSReactElement$fPToJSValReactElement$fIsJSValReactElementReactMlReactMlT runReactMlT ReactMarkup ElementMarkup TextMarkup BranchMarkup LeafMarkup LeafParam BranchParam fromMarkup fromElement toElements markedWindowmarkedElements markedElementtxtlfbh$fMonoidReactMlT$fSemigroupReactMlT$fMonadStateReactMlT$fMonadReactMlT$fApplicativeReactMlT$fFunctorReactMlT$fMonadFailReactMlT$fAlternativeReactMlT$fMonadPlusReactMlT$fMonadFixReactMlT$fMonadIOReactMlT$fMFunctorReactMlTReactComponent mkComponent$fToJSReactComponent$fPToJSValReactComponent$fIsJSValReactComponent$fDisposingReactComponentMaker MkHandler MkEmptyFrame MkRendererPutFrame GetComponentMkKey$fFunctorMaker mkHandler mkEmptyFrame mkRendererputFrame getComponentmkKey withActionhoistWithActionIsWidgetmkModelmkPlanwindowgadgetWidget SchemaType WithOutline WithGizmoGadgetOfWindowOfGizmoOfFrameOfSceneOfPlanOfModelOf OutlineOfActionOf CommandOfmkGizmomkGizmo'$fIsWidgetWidgetonRendermkActionCallbackruncomponentSetStatebasicRenderCmd js_renderunsafePropertyunsafeGetModifierStatejs_unsafePropertyjs_unsafeGetModifierState$sel:altKey:KeyboardEvent$sel:charCode:KeyboardEvent$sel:ctrlKey:KeyboardEvent#$sel:getModifierState:KeyboardEvent$sel:key:KeyboardEvent$sel:keyCode:KeyboardEvent$sel:locale:KeyboardEvent$sel:location:KeyboardEvent$sel:metaKey:KeyboardEvent$sel:repeat:KeyboardEvent$sel:shiftkey:KeyboardEvent$sel:which:KeyboardEvent$sel:altKey:MouseEvent$sel:button:MouseEvent$sel:buttons:MouseEvent$sel:clientX:MouseEvent$sel:clientY:MouseEvent$sel:ctrlKey:MouseEvent $sel:getModifierState:MouseEvent$sel:metaKey:MouseEvent$sel:pageX:MouseEvent$sel:pageY:MouseEvent$sel:relatedTarget:MouseEvent$sel:screenX:MouseEvent$sel:screenY:MouseEvent$sel:shiftKey:MouseEvent$sel:bubbles:Event$sel:cancelable:Event$sel:currentTarget:Event$sel:defaultPrevented:Event$sel:eventPhase:Event$sel:isTrusted:Event$sel:nativeEvent:Event$sel:target:Event$sel:timeStamp:Event$sel:eventType:Eventjs_isDOMEventTarget js_isDOMEventjs_isSyntheticEventjs_preventDefaultjs_isDefaultPreventedjs_stopPropagationjs_isPropagationStoppedjs_isMouseEventjs_isKeyboardEventbaseGHC.Realdivjs_mkBranchElementjs_mkLeafElementjs_textElementjs_mkCombinedElementstransformers-0.5.2.0 Control.Monad.Trans.State.Strict runStateTGHC.Basememptyjs_mkComponentjs_componentSetState