In my opinion it is okay to say your tool is revolutionary compared to existing ones. And it is hard to be fully unbiased about your own creation, I get it.

Tables are not yet supported. If you love impossible to read regular expressions, submit a PR!

I suppose it all comes down to tooling. It should be easy to author a pattern. A set of implicit (possibly explicit) patterns to author patterns may be useful.

Thank you to those who have failed many times, yet never gave up

A reasonably clean alternative would be to map a function over the array and use destructuring in the each loop: {#each [1, 2, 3, 4].map(n => ({ n, sqr_n: n * n })) as { n, sqr_n }} {sqr_n} {sqr_n / 2}<br> {/each}

I discovered that a solution can be hacked using an {#if}, but a proper one would be nice:

Every new variation to the view requires updating both the view model and the template. This holds true even for simple variations.

Offsetting the rules of a logic-less template requires a lot of helper methods.

Writing a logic-less template requires a bloated view model with comprehensive getters for the raw data. As a result, a messy and difficult-to-maintain view model usually accompanies logic-less templates.

that does not mean that I am advocating the other extreme–i.e., a templating language that allows a lot of logic. I find such templating languages, especially those that allow the host programming languages to be used inside the template, to be hard to read, hard to maintain, and simply a bad choice.

It's certainly something I've wanted to reach for prior

An alternative (maybe not good) would be to restrict {@const} to certain blocks like {#each} and {#if}. In both cases, it significantly reduces the "multiple ways to do the same thing" problem and avoids ergonomic and performance overhead of our current situation.

it also allows for more divergence in how people write there code and where they put their logic, making different svelte codebases potentially even more different due to fewer constraints. This last point is actually something I really value, I read a lot of Svelte code by a lot of different people and broadly speaking things look the same and are in the same places.

I had this problem and figured out how to make something like this work with the compiler quirks.

Here's a proxy store I wrote to derive the value of a store nested within other stores, it plays nice with typescript and can go infinitely deep

Generally, you should read the value of a store by subscribing to it and using the value as it changes over time. Occasionally, you may need to retrieve the value of a store to which you're not subscribed. get allows you to do so.

This reactive statement is just used to have the store automatically subscribed and unsubscribed.

I'm not sure I understand the problem, everything you are describing is already possible.

Svelte right now has a lot of opportunities to have component state become out of sync with props.

I'm suggesting this is a problem generally. Users will not think of being out of sync with props

Svelte doesn't re-render, so you need to respond to component mount/dismount and prop changes separately as they are distinct concepts and never tied together, unlike in React.

the code is a bit verbose/convoluted

To fix our Svelte version you might think we could use beforeUpdate or afterUpdate, but these lifecycle functions are related to the DOM being updated, not to prop updates. We only want to rerun our fetching when the album prop is changed.

When using React hooks there is no concept of onMount because the idea of only running some code on mount leads to writing non-resilient components, components that do one thing when they mount, and then don’t take prop changes into account.

Beautiful, except that switching albums does not update the PhotoGrid. This is not the automatic reactivity we were promised by Svelte.

Using another reactive statement with $effect we have Svelte automatically handle subscribing and unsubscribing to the store

I’d still be interested in Svelte making things easier so I’ve opened a feature request for Reactive statement cleanup functions.

It provides several capabilities that are difficult to achieve with React alone, while being compatible with the newest features of React.

For reasons of compatibility and simplicity, it's best to use React's built-in state management capabilities rather than external global state.

Sometimes, you may be tempted to write that wrapper. Because all your (React or Vue or insert your reactive framework here) instincts tell you so.Resist the temptation. There is a better way. A svelter way. Introducing: the use-directive (a.k.a. “actions”).

However, especially when starting out, it’s very easy to fall into the “this is how I did things in my previous framework” trap.

A “solution” to GR is more like a model in logic: it may satisfy a theory’s axioms but have other properties that are contingent (unless the theory is categorical, meaning that all of its models are isomorphic).

Safiya Noble, Algorithms of Oppression (New York: New York University Press, 2018). See also Mozilla’s 2019 Internet Health Report at https://internethealthreport.org/2019/lets-ask-more-of-ai/.

So that’s already a huge advantage over other platforms due the basic design. And in my opinion it’s got advantages over the other extreme, too, a pure peer-to-peer design, where everyone would have to fend for themselves, without the pooled resources.

“INFORMATION RULES”—published in 1999 but still one of the best books on digital economics—Carl Shapiro and Hal Varian, two economists, popularised the term “network effects”,

In the Ars memorandi noua secretissima, published in 1500 or 1501,20 Jodocus Weczdorff de Triptis (Weimar) inserted an alphabetical list of words, similar to that of Celtis, but he simply suggested that it could be used as a memory house without any scope for our private associations. Moreover, the alphabetic table of Celtis was included in the famous Margarita philosophica nova of Gregor Reisch, which was probably the most popular handbook of the artes scholars in the fi rst two decades of the 16th century.

“The Art of Memory in Late Medieval East Central Europe (Bohemia, Hungary, Poland): An Anthology,” co-written by Lucie Doležalová, Rafał Wójcik and myself.

In 1945 Jacques S. Hadamard surveyed mathematicians to determine their mental processes at work by posing a series of questions to them and later published his results in An Essay on the Psychology of Invention in the Mathematical Field.

MyScript MathPad

In April of 2019, at a digital learning conference, Manuel Espinoza spoke with educators, technologists, and annotation enthusiasts about R2L.d-undefined, .lh-undefined { background-color: rgba(0, 0, 0, 0.2) !important; }.d-undefined, .lh-undefined { background-color: rgba(0, 0, 0, 0.5) !important; }1Nate Angell and “the role that Hypothesis plays in human rights work.”

Horwitz argued a fairly radical point, which I think never received wide enough recognition due to the subject matter and his extremely difficult (dense and dry) style.  He said, “I seek to show that one of the crucial choices made during the antebellum period was to promote economic growth primarily through the legal, not the tax, system, a choice which had major consequences for the distribution of wealth and power in American society”

Universal Design for Learning: Theory and Practice by Meyer, Rose, and Gordon (a book recognized as the core statement about UDL, which you can read for free) walks us through how educators actively change their practice to become more inclusive and helps us weigh choices in terms of how we create unnecessary barriers:

Solid supports templating in 3 forms JSX, Tagged Template Literals, and Solid's HyperScript variant.

So while Solid's JSX and might resemble React it by no means works like React and there should be no illusions that a JSX library will just work with Solid. Afterall, there are no JSX libraries, as they all work without JSX, only HyperScript or React ones.

Unfortunately people lack the the time to invest to really understand those things

If there was a place I thought reactivity would be weak, I embraced it and I worked on it until I was happy with the results.

It was clear no one was interested in what I was working towards.

but everything they were doing started to make sense

I kept on wanting them to work like Fine-Grained reactivity, since it was much more intuitive.

Vue was always felt contrived for me.

I couldn't land on how I wanted to box primitives. Should I use a getter/setter, or function form like Knockout, or explicit get/set like MobX? These were all ugly.

Over time Adam, Surplus' creator, had less and less time to spend on the project and I decided to take my own shot.

I started Solid years ago before I thought anyone would be interested in using it. I only started promoting it because it had already achieved the goals I had set out for it.

Templates are prone to unnoticed runtime errors, are hard to test, and are not easy to restructure or decompose.

In contrast, Javascript-made templates can be organised into components with nicely decomposed and DRY code that is more reusable and testable.

The $: can also be used to trigger effects.

We can run effects when some data changes using watchEffect - it takes a function that runs whenever a reactive value used inside changes.

MobX - for me personally MobX is a far better way to manage state than React Hooks. It doesn't care about the UI layer so it can be used outside the React ecosystem, and it's simple to mutate data.

Note that if you are calling reset() and not specify new initial values, you must call it with no arguments. Be careful to avoid things like promise.catch(reset) or onChange={form.reset} in React, as they will get arguments passed to them and reinitialize your form.

It's really useful if your PR relates to an outstanding issue, so please reference it in your PR, or create an explanatory one for discussion. In many cases, features are absent for a reason.

If a part of the content deserves its own heading, and that heading would be listed in a theoretical or actual table of contents, it should be placed in a <section>. The key exception is where the content may be syndicated; in this case, use <article> element instead.

Confidence to express ignorance is a super power. One good way I hone this skill is by saying “Nothing to add” when I have nothing to add, instead of repeating what other people said.

React hook for creating a value exactly once. useMemo doesn't give this guarantee unfortunately - https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily

Because I haven't worked with React Native, and so I'm not a specialist in it, and developing a React Native version of this package would better be done by someone being an expert in React Native.

This library exports a single React Hook, useMethods, which has all the power of useReducer but none of the ceremony that comes with actions and dispatchers.

r self-r

A Kind Word for Bullshit: The Problem of Academic Writin

The Indian government is pushing a bold proposal that would make scholarly literature accessible for free to everyone in the country

But maybe this PR should still be merged until he finds time for that?

Sorry this sat for so long!

He says that he sees the combination of long form pieces and Q&A as a new level of support. “We used to have level one, which was sending a ticket to the help desk, and it was something we could easily resolve for you. Level two was a more complex problem that maybe required an engineer or specialist from a certain team to figure out. I look at this new system as a level zero.” Before sending us a ticket, folks can search Teams. If they find a question that solves the problem, great. If they need more details, they can follow links to in-depth articles or collections that bring together Q&A and article with the same tags.“

I created a pull request to have the if (node.parentNode) conditional added to detach. It was not applied due to the desire to find the root cause of the <meta> tag manifestation of this issue.

However, IMO, having the conditional in the detach function is necessary, because there are other manifestations of this error. For example, if the DOM element in a component is removed from software outside of svelte, detach will have the same error.

IMO, the conditional needs to be added to detach to fix all manifestations of this error.

remaining: 0, callbacks: [] r: 0, // remaining outros c: [], // callbacks p: outros // parent group

Why the obfuscation of remaining to r and callbacks to c? This is fine for function-local variables but in this instance makes the code significantly harder to reason about? There is no notion of what c and r mean.

I pushed the build files & tested it in my environment so this should work as is.

I pushed a hotfix, based on v3.6.3 proposed by #2086 (comment) In package.json, under devDependencies, use: "svelte": "btakita/svelte#svelte-gh-2086-hotfix"

do I really have to do something like that in order to have my local modules working? it's quite impracticable to explain it to a team! there's nothing a little bit more straightforward?

page components can have an optional preload function that will load some data that the page depends on. This is similar to getInitialProps in Next.js or asyncData in Nuxt.js.

This dynamic is playing out during the pandemic among the many people who refuse to wear masks or practice social distancing.

Keep in mind that the values in meta are dependent on you having subscribed to them with the subscription prop.

I guess we could always add a bunch of adapter code to watch the flag and trigger a callback when it becomes true or false...

The problem I have with this approach to state and prop variables is that the difference between them is very blurry. In React you can clearly see that a prop is an input to component (because of clear function notation), and that state is something internal. In Svelte they are both just variables, with the exception that props use export keyword.

Because Svelte is a compiler, we're not bound to the peculiarities of JavaScript: we can design a component authoring experience, rather than having to fit it around the semantics of the language.

/node_modules/

Insisting on a specific implementation, rather than proposing a clear problem, suggesting a possible solution, and “not being married” to your initial preferred solution.

Modules using code that doesn’t exist in browsers such as process.env.NODE_ENV and forcing you to convert or polyfill it.

The benefit of this approach is that rather than having these defaults and fighting against them, it’s fully up to you to decide how to handle everything.

Instead, rather than trying to implement what it thinks is the best way to bundle different type of assets, it leaves that entirely up to the developer to decide.

Personally for me, this is incredibly hard to read. Regex everywhere, nested objects with different rules and configurations that are very intuitive, multiple loaders that resolve backwards, built in loaders having obscure issues that require using third party loaders in between, separation of plugins and loaders, and so on.

In my opinion, because Webpack was one of the first bundlers, is heavily packed with features, and has to support swathes of legacy code and legacy module systems, it can make configuring Webpack cumbersome and challenging to use. Over the years, I’ve written package managers, compilers, and bundlers, and I still find configuring Webpack to be messy and unintuitive.

Unfortunately, many third party libraries, even though they are written in ESM, are published to npm as CJS modules, so we still need to concatenate them.

Wow, no answers to this question. That's too bad. Did you ever find the solution?

Did you know that you can create a Svelte component and with almost no extra steps distribute- and use it like any classic old Javascript library through a global constructor (let myComponent = new MyComponent())?

So I guess what @Rich-Harris is trying to say is that (sorry, I'm just logging it here for my own benefit)

we've learned why you might want to use external but not globals: libraries. We've started to factor some of our client-side JS as libraries to share between projects. These libraries import $ from 'jquery'. However they don't want to presume how that import might be "fulfilled". In most projects it's fulfilled from a global i.e. a script loaded from a CDN. However in one project it's fulfilled from a local copy of jQuery for reasons I won't get into. So when these libraries bundle themselves for distribution, as ES6 modules, they mark 'jquery' as an external and not as a global. This leaves the import statements in the bundle. (Warning: Don't bundle as an IIFE or UMD, or Rollup will guess at fulfilling the import from a global, as @Rich-Harris mentions above.)

There are two ways of handling this with Rollup, as described by the troubleshooting link from the warning. Unfortunately, both Rollup and React recommend the wrong one.

Luckily, there is absolutely no good reason not to use strict mode for everything — so the solution to this problem is to lobby the authors of those modules to update them.

small modules allow library authors to become lazy. Why include that six-line helper function when you can do a one-line `require`?

These are all things that make your life as a library author easier.

This happens because npm makes it ridiculously easy for people to release their half-baked experiments into the wild. The only barrier to entry is the difficulty of finding an unused package name. I’m all in favour of enabling creators, but npm lowers the barriers right to the floor, with predictable results.

I think I know why: it’s because the small modules philosophy favours library authors (like Sindre) at the ultimate expense of library users.

I hope I won’t forget, but I’ll come back to you once we’ve got an idea on how to improve this Svelte API

DX: start sapper project; configure eslint; eslint say that svelt should be dep; update package.json; build fails with crypt error; try to figure what the hell; google it; come here (if you have luck); revert package.json; add ignore error to eslint; Maybe we should offer better solution for this.

When the message say function was called outside component initialization first will look at my code and last at my configuration.

GitHub issues aren't the right place for support questions like this. Please ask on StackOverflow or in our Discord chat room.

The recommended solution for onMount is the same as for useEffect — place an async function inside the handler

(Note that you're responsible for handling any race conditions that arise as a result of the component being destroyed before the promise resolves, though assigning state inside a destroyed component is harmless.)

Most simple example: <script> import ChildComponent from './Child.svelte'; </script> <style> .class-to-add { background-color: tomato; } </style> <ChildComponent class="class-to-add" /> ...compiles to CSS without the class-to-add declaration, as svelte currently does not recognize the class name as being used. I'd expect class-to-add is bundled with all nested style declarations class-to-add is passed to ChildComponent as class-to-add svelte-HASH This looks like a bug / missing feature to me.

Also Svelte is so great because developer do not need to worry about class names conflict, except of passing (global) classes to component (sic!).

I wrote hundreds of Rect components and what I learned is that Componets should be able to be styled by developer who is using it.

I think instead, there would need to be some special way to make the distinction of what is a slot attribute and what is a slot prop to be consumed with let:. Maybe a new directive like <slot attr:class="abc"/>?

I can't add special props and keywords to every single component I have and will ever create for this to work.

There are work arounds, but nothing clean. I just feel like this should be functionality that should be part of the slot feature.