This was implemented (completely differently to anything discussed in this issue) in #642.

Like JSON.stringify, but handles

This is an opportunity to fix a bug: if you're on a page that redirects to a login page if there's no user object, or otherwise preloads data specific to that user, then logging out won't automatically update the page — you could easily end up with a page like HOME ABOUT LOG IN ----------------------------------------------------------------------------------------- Secret, user-specific data that shouldn't be visible alongside a 'log in' button:

Unless we choose to use the semver ju-jitsu of calling the changes a bugfix

Some devs prefer Svelte’s minimal approach that defers problems to userland, encouraging more innovation, choice, and fragmentation, and other devs prefer a more fully integrated toolkit with a well-supported happy path.

Making UIs with Svelte is a pleasure. Svelte’s aesthetics feel like a warm cozy blanket on the stormy web. This impacts everything — features, documentation, syntax, semantics, performance, framework internals, npm install size, the welcoming and helpful community attitude, and its collegial open development and RFCs — it all oozes good taste. Its API is tight, powerful, and good looking — I’d point to actions and stores to support this praise, but really, the whole is what feels so good. The aesthetics of underlying technologies have a way of leaking into the end user experience.

It's true that Svelte does not allow you to map over children like React, but its slot API and <svelte:component> provide similarly powerful composition. You can pass component constructors as props and instantiate them with <svelte:component>, and use slots and their let bindings for higher order composition. It sounds like you're thinking in virtual DOM idioms instead of Svelte's.

However, Svelte isn't React or Vue or any other framework, the same approach will not always work and given that Svelte has very different constraints and approach that works well in another framework is not suitable with Svelte. Trying to apply approaches use with other frameworks to Svelte will invariably end in frustration.

Each area requires specific learning and thinking in a certain way. Front-end is user centric, back-end is closer to algorithms and parallel programming, databases require thinking in streams of data based on a model (similar to set theory and model checking).

To stay up-to-date with the new parts, just follow this medium or observe me on Twitter. In case you need some help, remember that I am open for consultation.

If you'd prefer, you can use a third-party library like Modernizr or Detect It to do this test for you.

Better community building: At the moment, MDN content edits are published instantly, and then reverted if they are not suitable. This is really bad for community relations. With a PR model, we can review edits and provide feedback, actually having conversations with contributors, building relationships with them, and helping them learn.

I think the main difference between the two are the way API are served. Some smelte components need you to input big chunk of json as props, while i prefer keep props as primitive types and in the other hand give you different components tags to compose.

I don't think this is what really matters at the end, since whatever is the implementation the goal should be to provide a library that people actually like to use.

I wouldn't use Flutter for web, mobile is good though.

It's super promising for web apps, just maybe not for web pages. I went from React to Svelte to Flutter for my current app project, and every step felt like a major upgrade.Flutter provides the best developer experience bar none, and I think it also has the potential to provide the best user experience. But probably only for PWAs, which users are likely to install anyway. Or other self-contained experiences, like Facebook games. It does have some Flash vibes, but is far more suitable for proper app development than Flash ever was while still feeling more like a normal website to the average user. It won't be the right choice for everything, but I believe it will be for a lot of things.

This one gets the SEO, so I hope you're successful @raythurnevoid.

Programmers working in different kinds of programming languages often come up with radically different solutions to problems.

After some attempts mapping with Svelte, I missed using canvas instead of SVG

In the past, I tried to create some proof of concepts with svelte, but I usually ended up missing some of the features that RxJS provides. Now that I know that they complement each other well, I will grab this combination more often

Another difference is that context in Svelte does not insert anything into the visual component tree. There is no <Context.Provider> element like in React

I'm still calling this v1.00 as this is what will be included in the first print run.

Depending on your needs, you can use the Simple Approach: Wrapping MDC Web Vanilla Components, or the Advanced Approach: Using Foundations and Adapters.

However, this construct is not completely equivalent to if ... fi in the general case.

I know this is existing code but we can probably use this as an opportunity to "fix" it: it is discouraged to use the async exists method to check for a file and try operating on it.

Converting Angular components into Svelte is largely a mechanical process. For the most part, each Angular template feature has a direct corollary in Svelte. Some things are simpler and some are more complex but overall it's pretty easy to do.

Express - 19 $ 🏃‍♀️ Skip the Review Queue 🕒 Published in 3 days 💌 Full Customer Support 💚 Support the team

You can support my work on this project through my other project, Tunnelgram.

Internal Sass features have also moved into the module system, so we have complete control over the global namespace.

Quick self-promotion plug (but in the name of altruism)

Thanks for the PR @RedHatter. I think it's important to be able to specify which warnings are being disabled, and I'm nervous about the use of the code frame for this sort of thing (feels brittle), so I've opened a new PR, #3351. Will close this in favour of that

Some of the verbs implemented by systemctl are designed to provide a high-level overview in a human readable format. All that information is available over dbus, and/or journalctl, systemctl show. We could provide that information in json format, but there's a second problem. Information and format of information printed by e.g. systemctl status is not stable. Since the output is not suitable for programmatic consumption anyway, there's no need to provide it in a machine readable format.

Although I agree that -o json should return proper JSON, believe the proper way for external tools like SaltStack etc. to talk to systemd is DBus. See also saltstack/salt#20392 - everything else is more or less just hack-ish and prone to break easily.

If you have a better/simpler/"more official" solution, I'd still love to see it!

is this solution considered a hack or is something that we can use as an approved workaround in scenarios where we need to manually trigger validations?

Library author here. I'm always fascinated by new ways people can invalidate my assumptions. I mean that in a sincerely positive way, as it results in learning.

The more official way to do this would be to run the check (you could even reuse this.validate) in onSubmit.

This is a philosophical issue, I think. People (and presumably form libraries) have different definitions of what "dirty" means. Yours: "The field has ever been edited" Mine: "The value of the field is different from the initial value"

Oops, I had not read your original description closely enough.

you took 4 hours to respond, so I implemented it myself

withindex.js, we have a single source of truth, giving fine grained control on what we expose to the outside world.

The reason that this solves our problem is: we now have full control over the module loading order. Whatever the import order in internal.js is, will be our module loading order.

Link to https://ponyfill.com in your readme. Example. Add ponyfill to the keywords section in package.json.

Use ponyfill.com for linking here.

You might be interested in my products:

Once again, this isn’t good or bad, it’s just the most efficient way to create something that is similar to something else

mixing the turing complete of javascript with the markup of HTML eliminates the readability of JSX so that it is actually harder to parse than a solution like hyperscript

One of the primary tasks of engineers is to minimize complexity. JSX changes such a fundamental part (syntax and semantics of the language) that the complexity bubbles up to everything it touches. Pretty much every pipeline tool I've had to work with has become far more complex than necessary because of JSX. It affects AST parsers, it affects linters, it affects code coverage, it affects build systems. That tons and tons of additional code that I now need to wade through and mentally parse and ignore whenever I need to debug or want to contribute to a library that adds JSX support.

Supporting JSX out of the box is the engineering equivalent of Mozilla supporting DRM out of the box in FireFox.

If the react cargo cult didn't have the JSX cowpath paved for them and acclimated to describing their app interface with vanilla javascript, they'd cargo cult around that. It's really about the path of least resistance and familiarity.

The only "issue" it has is that its unfamiliar. People have been working with HTML for years and are comfortable with it. That's basically the only reason that people find it more readable. If you make an effort to spend sometime with hyperscript, it becomes as familiar and readable as jsx.

if you think this project can help you or anyone else, you may star it on GitHub

For event listeners we support the standard jsx naming convention onEventname (this is converted to on:eventname in svelte) as well.

This proposal simplifies how React.createElement works and ultimately lets us remove the need for forwardRef.

This balancing act needs to take into account project complexity (size, distribution, etc.), uncertainty (risk, innovation need, etc.), and the cost of change at the project level and for each major component.

Compounding the problem of iteration disguised as oscillation is the cost of change.

Incurring high-cost changes isn't evolutionary design-it's oscillation caused by poor planning and requirements specification on a high cost-of-change component-it tips the anticipation/adaptation balance too far towards adaptation.

although this is also an opportunity to clean up someone else's mess

Svelte takes advantage from its position as compiler to make reactivity a language feature

took advantage of your imposed staycation

We are very close to full inline components (with css, js logic, and templates).

About the argument against it, "{@const will make code less consistent ": I think the same is true now, since people can come up with very different ways of dealing with the "computed value inside each loop/if function" problem. Some extract components, some use functions, some will prepare the array differently beforehand.

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

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

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.

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.

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

but everything they were doing started to make sense

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.

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.

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.

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.

While Webpack is focused on using CommonJS as its primary module system and converting everything to that, Rollup decided to take the opposite approach — focusing on ES Modules instead.

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.

But this is only a halfway decent way to clarify that this is an external dependency, because the only way to resolve a peer dependency warning is to install react from npm—there's no way to notify npm that you resolve the dependency to a browser global. So peer dependencies should be avoided in favor of external declarations. Then Rollup will take care of warning about "unresolved dependencies", even if external declarations can't express a particular version range with which your library is compatible like peer dependencies can.

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.

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.

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

If you want this control then wrap them in a DOM node that the parent controls. If you want to pass in values then use props and if you want to pass in values from higher up the tree, the new style RFC may be able to help.

new style RFC

The problem with working around the current limitations of Svelte style (:global, svelte:head, external styles or various wild card selectors) is that the API is uglier, bigger, harder to explain AND it loses one of the best features of Svelte IMO - contextual style encapsulation. I can understand that CSS classes are a bit uncontrollable, but this type of blocking will just push developers to work around it and create worse solutions.

I think Svelte's approach where it replaces component instances with the component markup is vastly superior to Angular and the other frameworks. It gives the developer more control over what the DOM structure looks like at runtime—which means better performance and fewer CSS headaches, and also allows the developer to create very powerful recursive components.

<LazyLoad component="img" data-src="giant-photo.jpg" class="my-cool-image" />

<LazyLoad> <img data-src='giant-photo.jpg'/> </LazyLoad>

You should install the packages individually. Alternatively, you can install all of them at once with the svelte-material-ui package.

Aside from being an implementation nightmare, I think the proposal in this RFC is strictly better than props-in-style — it gives you the same expressive power in a neater, more idiomatic way, along with the global theming ability.

This has the merit of simplicity and obviousness, but it's not particularly ergonomic: it signals that we don't consider component themeability to be a problem worth solving properly.

There are tools in Svelte that break this expectation to a degree, but they are a bit annoying to use, which makes it an active decision on the part of the developer. The API hints at the way we want you to do things because we feel that this will give the better experience.

Most of the linked issues, as well as this RFC, attempt to solve this problem by relaxing Svelte's CSS scoping rules, providing a better API with which to use global, or by manually passing down classes. We have never found this to be an acceptable solution which is why those issues have been closed. That position has not changed.

Or if we formally took a stance that the class prop is THE ordained way to pass class attributes, though I don't think this functionality warrants this restriction.

It’s amazing how easy it is to make these HTML pages with Rails generators. But of course, it can’t last.

React doesn’t provide something like ng-class, but there is a great library called classnames that does the same and more. Install it:

FWIW, I would have raised it earlier if I thought it would have made a difference.

As a web designer, I hate that "log in" creates a visual space between the words. If you line up "Log In Register" - is that three links or two? This creates a Gestalt problem, meaning you have to really fiddle with spacing to get the word groupings right, without using pipe characters.

As a later iteration, it might be cool to see a link between the quoted content and my comment

For example, as the GDPR requires that a controller must be able to demonstrate that valid consentwas obtained, all presumed consents of which no references are kept willautomatically be below theconsent standard of the GDPR and will need to be renewed. Likewise as the GDPR requires a“statement or a clear affirmative action”, all presumed consents that were based on a more impliedform of action by the data subject (e.g.a pre-ticked opt-in box) will also not be apt to the GDPRstandard of consent.

The cookie banner will be displayed any time a user visits your site for the first time or when you have decided to add a new vendor to your list of vendors (since it’s a new disclosure and potentially a consent request for that vendor may be required).

Designers are tempted to enforce users to actually use the interface or browse through the site they have created.

Matz, alas, I cannot offer one. You see, Ruby--coding generally--is just a hobby for me. I spend a fair bit of time answering Ruby questions on SO and would have reached for this method on many occasions had it been available. Perhaps readers with development experience (everybody but me?) could reflect on whether this method would have been useful in projects they've worked on.

Sites Built with React-Static

The element dem in epidemic, endemic, and pandemic comes from the ancient Greek word demos, which meant people or district:

A "tag" is a snippet of code that allows digital marketing teams to collect data, set cookies or integrate third-party content like social media widgets into a site.

Taxonomy, in a broad sense the science of classification, but more strictly the classification of living and extinct organisms—i.e., biological classification.

they’ve contested its accuracy

For instance, one recent blog entry from the Irish Data Protection Commission discussing events at schools borders on the absurd:“Take the scenario whereby a school wants to take and publish photos at a sports day ­– schools could inform parents in advance that photographs are going to be taken at this event and could provide different-coloured stickers for the children to wear to signify whether or not they can be photographed,” the Commission suggested. The post goes on to discuss the possibility of schools banning photographs at a high school musical, but suggests that might be unwieldy.

Short of a fingerprint reader, two-step verification (aka two-step authorization) may be the single best way to protect online accounts.

2-Step Verification