o0101 / good.html Goto Github PK

• rectangular selection visual cue
• copy (into json quoted string, csv format) and paste (from same format)
• implement formula translation (moving a2 => c4, b5 -> d7)
• apply formula translation on paste

replace with event.composedPath()

After removing the elaborate type checking code for performance, the lack of type checks (we still have some, but not all we did before) allows some values to be passed through our process pipeline that would not have been before.

for instance, in the cells component (and this is the only real place it occurs because normally we don't permit setting arbitrary JS values in templates--the author decides what values to put there, not the user--but in cells the user decides) we can set a cell formula like so

A1: abcdef
A2: =/[a-z]/g
A3: =a1.match(a2)

the value of A3 will be an Array. Not a VVArray (array of components / HTML produced by VV), just an array. In this case of strings.

So what happens is our process code just gets stuck in an endless loop on this. Let's fix this.

this will pull that component out of the loading counts for the rest of the page, and give it its own counts scope which will be inherited by all subrequests of that component, effectively making the component and the rest of the page load separately.

Means you can put lazy on a massive component, load the rest of the page fast, while this other component loads essentially "in the background" without affecting the load time of the rest of the page.

FUCK YEAH! :P ;) xxx

hahaha

maybe I should put it in a webworker first

So rather than doing merging as we recently transitioned to do (in order to not indicate to every sub view that a new state object has been passed to them (a new state reference)), we make it so that we can pass new references (clones), but that we check equivalence (likely JSON === JSON) to avoid attempting a re-render when nothing changed.

I think I'm doing this already. Possibly, because I'm using JSON equiv checks (which only prevents equivalence being incorrect claimed, but still permits difference to be incorrectly claimed (when the keys have the same values but present in the JSON in different orders)) to determine whether to render or not because: 1) I do have minimal re-renders and 2) the only signal for that, since the state object references are the same (because we are merging not cloning), is the JSON equivalence.

So I think to implement this all I need to do is remove any logic where a reference difference implies a logical difference from the equivalence checks.

everytime we render a component we need to bring its stylesheet in (at least if it's a first time render). We should cache stylesheet URLs in a global cache.

this is to save work when calculating the formulas

so we can select one cell or one rectangle and then we can add another such, and so on, forever

by holding down some key or by doing something on mobile i haven't worked out yet

we can also subtract selection parts from the selection

when pasting the gaps between regions are preserved

so work scheduler falls back to good old list.map(func) if component already built.

so we have responsive loads and fast updates.

probably passing in some sort of node object into the state (under _node ?) so work scheduler can check this, (alreadyPrinted or whatever)

• also see if there is any way to speed up updates on a large component, such as by only mapping / iterating those rows / cells, where the state they reference (state attr, state key, state object) has actually changed.

in total as a template tag function, could be, wrapping or merging with _FUNC

say I want to watch 'type' on host, then set type on sub components, how to implement in general way?

just re-render? or other

• autocomplete search component
• infinite table component
• multiple file upload with progress bar and preview component
• single image upload with crop / filter component
• blog/feed/CMS post component with client-side sanitization
• text comment component with client-side sanitization

https://www.jackfranklin.co.uk/blog/working-with-react-and-the-web-platform/

do it by adding bang-el to the app root (body, say) then adding bang-styled once every has loaded

this would mean a significant perf improvement as the main overhead right now is from the requests for component files

we already have minimal diffing, but this can help avoid unnecessary print calls which occur with descendants when the ancestors setState (which changes object references to all state objects sent to descendants by reference not by string key)

like when something changes...? but it's hard to specify. we have on bond for first time the tree is attached to DOM....

it seems we are not scanning shadow dom when it is reprinted for any bang tags there.

why observer not work?

• bug with nodes removed not able to be re-added using vv, workaround is creating new keys to force new nodes
• linkedCustomElement not update when we update the comment, so workaround is using start and end tags instead of bang tags
• optimizations bug re #10 where nothing is updating, even tho state is

not on the whole state, then we roll back the entire page

from bb upstream.

on only one of multiple children

unknown genesis

to enable adding get() post() etc endpoints server side that would be automatically pulled in by BANG! server side into an express like server at the correct component path route

Loading. how?

something in place of the element? How? Where in the cycle? Where in the flow?

What CSS styles? What markup? What scripting, if any, begat from this requirement?

and note how naked method names are are automatically transformed into correct references to the relevant class component

Ok

so when dragging for size:

• adjacent column cannot become selected
• we may highlight the entire dragged column
• we definitely should highlight the column / row border at the point that is being dragged

this will help indicate to people where they should press next time and what area their action is affecting

like the one i saw

because it replace its original comment in the template with the custom element

so instead of using cloneState and setState

we can use

this.state.myProp = myVal

etc

mitigation, preserve scroll positions and set them after ending the drag sizing

If we are adding some new nodes we should be able to do it without changing entire list

See if possible

• support passive event listeners
• load only a small window out of infinite number of rows and columns
• try preview / commit two phase resizing for performance and to avoid scroll snap jank issues
• alternately try switching off scroll snap during resize dragging

So we can call render on each component if we wish

Keep a double end queue or a heap in order to keep the actual visual order of the available to be printed into the data sync