o direito de saber,

Is motivated partisan cognition bipartisan?The extent to which each side exhibits motivated partisan (or biased) cognition is a focus of ongoing debate. Some scholars argue for symmetry (SM). For example, a recent meta-analysis demonstrates equivalent levels of motivated partisan cognition across 51 experiments investigating the tenden cy to evaluate otherwise identical in-formation more favorably when it supports versus challenges one’s political beliefs or allegiances (14). In an illu strative experiment, liberals and conservatives viewed a film clip of a political demonstration in which protestors clashed with police. Despite view-ing the identical clip, liberals rated the protesters as more violent when they believed it was an anti-abortion protest (a conservative cause) rather than a gay-rights protest (a liberal cause), whereas conservatives exhibited the opposite pattern (SM). Other scholars argue for asymmetry. For example, some evidence suggests that, relative to Democrats, Republicans have a higher need for order and greater trust in their gut-level intuitions. Such tendencies appear to motivate them to favor explana-tions that are straightforward and intuitive rather than complex and abstract, even when the latter types of explanation might be more accurate (15) (SM). Such findings are representative of the existing evidence, but conclusions remain tentative.

Jbuilder gives you a simple DSL for declaring JSON structures that beats manipulating giant hash structures. This is particularly helpful when the generation process is fraught with conditionals and loops.

The Web Storage API provides mechanisms by which browsers can store key/value pairs, in a much more intuitive fashion than using cookies.

I guess it's about "preloading" and not "navigation", if it's the case, then I guess there is still no way to attach to navigation events, and this issue should be kept open.

No JS event is fired, so there currently isn't any clean way to do this that I can see.

The only solution that I can see is to ensure that each user gets their own set of stores for each server-rendered page. We can achieve this with the context API, and expose the stores like so: <script> import { stores } from '@sapper/app'; const { page, preloading, session } = stores(); </script> Calling stores() outside component initialisation would be an error.

I tried leaking session and page data and indeed it's easy. Too easy. So I definitely agree that session data should not be readable from anywhere but the request itself.

Like JSON.stringify, but handles

This would be cumbersome, and would encourage developers to populate stores from inside components, which makes accidental data leakage significantly more likely.

which makes it much harder to accidentally keep logged-in state visible after a client-side logout

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:

We usually only see people launching projects once they're already done. I'm sure there are countless more unfinished and unlaunched side projects that the world will never know about. Don't let your side project become one of them.

They say that perfect is the enemy of good, and I'm coming to realise that something like a video course can never be perfect anyway. I can only do my best with the time and energy I have available. I'd rather finish this course and share my experience and insights on using Svelte with the world, than to plan it forever and never launch.

People really don't stress enough the importance of enjoying what you're programming. It aids creativity, makes you a better teammate, and makes it significantly easier to enter a state of flow. It should be considered an important factor in choosing a web development framework (or lack thereof). Kudos!

You can afford to make a proper PR to upstream.

The change would be useful to other people as-is.

No more waiting around for pull requests to be merged and published. No more forking repos just to fix that one tiny thing preventing your app from working.

Yarn only runs the postinstall hook after yarn and yarn add, but not after yarn remove. The postinstall-postinstall package is used to make sure your postinstall hook gets executed even after a yarn remove.

# fix a bug in one of your dependencies vim node_modules/some-package/brokenFile.js # run patch-package to create a .patch file npx patch-package some-package

Can we just forward/bubble all events emitted by the underlying input element?

Can this be merged please, this fixes a problem I have

Slots can already be pretty confusing to comprehend, I think it is better to stick to what people (may) already know.

Also agree that <svelte:slot> is perhaps a little confusing since it replaces the slot attribute rather than the slot element, so <svelte:fragment> would make more sense

May I ask what is holding this back?

Just to reiterate the discussion on the RFC, there was a suggestion that we change <svelte:slot slot="foo"> to <svelte:fragment slot="foo">, since it's the counterpart to a <slot> rather than an equivalent to it

Huh, to be honest, I'd expect assigning multiple elements to the same slot to fail at compile time unless the multiples were inside mutually exclusive conditionals. If the multiples were outside statically resolvable mutually exclusive conditionals I'd expect to see a runtime error.

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.

It’s worth mentioning that Svelte limits its scope to being only a UI component framework. Like React, it provides the view layer, but it has more batteries included with its component-scoped CSS and extensible stores for state management. Others like Angular and Vue provide a more all-in-one solution with official routers, opinionated state management, CLIs, and more. Sapper is Svelte’s official app framework that adds routing, server-side rendering, code splitting, and some other essential app features, but it has no opinions about state management and beyond. 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.

It’s worth mentioning that Svelte limits its scope to being only a UI component framework. Like React, it provides the view layer, but it has more batteries included with its component-scoped CSS and extensible stores for state management.

With some frameworks, you may find your needs at odds with the enterprise-level goals of a megacorp owner, and you may both benefit and sometimes suffer from their web-scale engineering. Svelte’s future does not depend on the continued delivery of business value to one company, and its direction is shaped in public by volunteers.

but really, the whole is what feels so good.

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 seems being able to bind:this={slotEl} directly on a slot element is a popular request. I'll add my +1 as adding div wrappers just to get dom references gets old really fast.

I changed if (value) { to if (typeof value !== "undefined") { as it was skipping some keys

Be careful when returning an object literal in the arrow function shortcut syntax like this. Don't forget the additional parens around the object literal!

Got a bit sidetracked into refactoring the Element visitor code, so haven't actually started on the event handler stuff per se, but that'll come soon. Element stuff is starting to feel a bit more logical and easier to follow.

Convention in Java, and I believe most other languages, is to use Listener suffix for historical reasons!

Event listener and event handler are two terms that cause confusion.

The most basic difference is the association Listener is associated with Event Source (Ex: key board) Handler is associated with an Event (Ex: keydown)

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

In a browser, the chrome is any visible aspect of a browser aside from the webpages themselves (e.g., toolbars, menu bar, tabs). This is not to be confused with the Google Chrome browser.

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.

Better contribution workflow: We will be using GitHub’s contribution tools and features, essentially moving MDN from a Wiki model to a pull request (PR) model. This is so much better for contribution, allowing for intelligent linting, mass edits, and inclusion of MDN docs in whatever workflows you want to add it to (you can edit MDN source files directly in your favorite code editor).

Less developer maintenance burden: The existing (Kuma) platform is complex and hard to maintain. Adding new features is very difficult. The update will vastly simplify the platform code — we estimate that we can remove a significant chunk of the existing codebase, meaning easier maintenance and contributions.

Popular architectures deal with heavy traffic loads by adding logic to cache popular views and resources.

Everything Lives in GitWith a Jamstack project, anyone should be able to do a git clone, install any needed dependencies with a standard procedure (like npm install), and be ready to run the full project locally. No databases to clone, no complex installs. This reduces contributor friction, and also simplifies staging and testing workflows.

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 personally think that starting from google's components makes easier to keeping update to material specs updates.

Ariela had written a book about the history of theeveryday law of slavery in the U.S. Deep South that emphasized localculture and law,

Martha S. Jones,Birthright Citizens: A History of Race and Rights in AntebellumAmerica

But something about the comforting rigidity of the process, its seductive notation, but perhaps mostly its connotations of intellectual privilege, has drawn a diverse selection of disciplines to the altar of mathematical reasoning. Indeed, the widespread misappropriation of the language of mathematics in the social and biological sciences has to be one of the great tragedies of our time.

There's a huge area of seemingly obvious user-centric products that don't exist simply because there isn't a working business model to support it.

Traditional online funnels — more often than not — require you to have a separate:Content management system (ex. WordPress, Joomla)Web host (ex. SiteGround, Bluehost)Page builder (ex. Elementor, Beaver)Email autoresponder (ex. MailChimp, Aweber, GetResponse)Order formShopping cartWeb analyticsOther marketing tools

If you want a reference to the global object that works in any context, you can read this from a directly-called function. const global = (function() {return this})();. This evaluates to window in the browser, self in a service worker and global in nodejs.

emphasizing that 'this' and 'global object' are two different things not only in Node.js but in JavaScript in general

delete myObject.regex; // or, delete myObject['regex']; // or, var prop = "regex"; delete myObject[prop];

Svelte by itself is great, but doing a complete PWA (with service workers, etc) that runs and scales on multiple devices with high quality app-like UI controls quickly gets complex. Flutter just provides much better tooling for that out of the box IMO. You are not molding a website into an app, you are just building an app. If I was building a relatively simple web app that is only meant to run on the web, then I might still prefer Svelte in some cases.

All projects here are completely frozen, though feel free to fork and continue using them on your own.

As was mentioned in the comments above, the material design spec for buttons specifies that the text should be uppercase, but you can easily override its CSS property: paper-button { text-transform: none; }

You already have the reason: to raise distinction

So I assume the main reason is for distinction from regular text.

Note: Yes, it is sentence case, and yes, there should be a full stop if it was true sentence case — but for the love of all things good and designy, please don’t add a full stop.

Secondary buttons are the ‘go back’ to the primary button’s ‘next’, or the ‘cancel’ button to the ‘submit’ button

enables passive event listeners by default for some events (see list below). It basically will set { passive: true } automatically every time you declare a new event listener.

I open this issue to announce that i'm actively working on a rewrite of this library to accomplish these goals:

I hope @hperrin you're still alive to discuss about this and eventually for a pull request.

Preview/beta release (I wish @hperrin allows it to pull request it here)

For use$ since svelte is never going to support actions for components, i designed something that reminds React hooks that will in some ways replace this feature.

It is very important that "production ready" UI libraries are available because otherwise the use of Svelte cannot be argued. A key point would be to make it easy possible that people can contribute

@monkeythedev can your work be used already? I would suggest not yet, i'm still doing core changes every day

@monkeythedev I am curious how do you "organize" your work - You forked https://github.com/hperrin/svelte-material-ui and https://github.com/hperrin/svelte-material-ui is not very active. Do you plan an independent project ? I hope the original author would return at some times, if not, i'll see

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

I agree, it would be great to join forces and speed up development... Svelte really needs one safe material library option.

Maybe @hperrin would be able to make an appearance and select a few additional maintainers to help out.

There is no rerender, when you call listen, then all scroll events will warn on chrome. See this entry from svelte: breaking the web

You can also see this repo: default-passive-events.

If you continue to have trouble though, feel free to open a new issue so we can keep this one focused on the theme color palette documentation problem. 1 Pick your reaction

@use "@material/theme" with (  $primary: #FEDBD0,  $on-primary: #442C2E);

In the case of email, it can be argued that the widespread use of the unhyphenated spelling has made this compound noun an exception to the rule. It might also be said that closed (unhyphenated) spelling is simply the direction English is evolving, but good luck arguing that “tshirt” is a good way to write “t-shirt.”

Svelte makes the pit of success larger because it hides all of this from us at compile time.

At the start this is hard to get right, and bad practices will sneak into the codebase.

You could totally just write your own name and not use the name in package.json, this template is made so the users wouldn't need to think about the UMD build.

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

It's remarkable how much strategy and screwage can derive from just a pair of actions

So handling the interop upfront will avoid users writing invalid ES6 and make sure that they write ES6 that loads CommonJS in the right way.

Not being cancelable makes validating dialog content impossible - eg a login dialog or anything that takes user input. Of course, it's easy enough to get around - but I think this should be a requirement of a dialog.

To bundle this in your own code, use a Sass processor (not a Sass Svelte preprocessor, but a Sass processor)

If everyone did this, the repair shops would be out of business.

Why let other websites and social platforms tell your story? Share the real, authentic you the way you want to, and when you want to.

It is important to notice that if you are planning on making your application a PWA, you don’t have to rewrite all the logic.

I wonder if it's worth archiving the repository (while leaving the site running) with a message that we're transitioning the content to MDN (so folks don't get the wrong idea and a bad experience when filing issues).

Chevy tried an all-emoji press release about a new car that came across as very forced, proving that less is more when it comes to using emojis in emails. Not to mention, it’s almost impossible to decipher the message they’re trying to communicate.