I'm not sure what behaviour it is that you expect. "$; foo = bar.a" means that you expect foo to always be whatever bar.a is, and "bind:value={foo}" means that you expect foo to to be whatever has been entered in the input. It can't be both!

having inconsistencies when all the "subtle" conditions were met is unfriendly. it requires the user to have much deeper understanding of the nuances of the language.

I used the word "intended" behavior, because that is the behavior im looking for, but I may not be expressing it correctly in Svelte. It may not be the expected behavior of the code.

My mental model has always been that a reactive declaration like $: b = a * 2 defines b in it's entirety ("Here's my recipe for b and all the ingredients, please Svelte make b always up to date"). And outside of this declaration b is immutable.

For me there is a distinct difference between these two scripts: let a = 1; $: b = a * 2; let a = 1; let b; $: { b = a * 2 }; The first example defines a "recipe" for how to create b and b is completely defined by that declaration. Outside of that it is immutable, data flows only into a single sink. The second example declares a variable b and then uses a reactive statement to update it. But it also allows you to do with b whatever you want. If someone wants to go that route (definitely not me), they are free to do so at their own risk of ensuring consistency.

First of all, here is what I meant by updating reactive declared variable

The intention of the issue #2444 was to propagate the changes of the reactive declared variables back to its dependencies. in the context of this example, would meant, updating b should update a as well.

The intended behavior for the code snippet above is to reactively update b when a changes allows b temporarily go "out-of-sync" of a when calling update, setting b to 42 in this case, b is not always a * 2 however, if a changes again, b will be updated back to a * 2, instead of staying at 42

We should instead invalidate the ultimate dependencies of filtered rather than filtered itself:

You declare a reactive variable and it's dependencies ("recipe").

I don't think these are two different interests in contrast with each other. I wanna update that temporary object and when the dep changes I re-create the temporary object. Simple as that.

Svelte currently consistently gives the reactive statement priority over your checked binding.

I ran onto this issue too, causing double fetch request at each change.

Oh, I just figured out a workaround for my project, in case it helps someone. If you want the source of truth on the prop to come from the child component, then leave it undefined in the parent. Then, you can make the reactive variable have a condition on the presence of that variable. eg: <script> let prop; $: prop && console.log(prop); </script> <Child bind:prop/> Might not work for every use case but maybe that helps someone.

This has been particularly harmful when there is an http API call when val changes ... which triggers the call twice for no reason.

maybe this just comes down to general footguns with reactivity, and being aware of them as a developer.

Pros & Cons

Absolutely shockingly awful game from a company that puts out poor quality games. And furthermore, tries to sue YouTubers who don’t like their games for ‘slander’. Shocking games and shocking developers. Avoid at all costs.

Rails 5 recently shipped, and among many other new features is a new renderer that makes it easy to render fully composed views outside of your controllers.

UserMailer has gone untouched and the code remains as clear in its intent and expression as it was when it was written.

When you give an element a width of 100% in CSS, you’re basically saying “Make this element’s content area exactly equal to the explicit width of its parent — but only if its parent has an explicit width.” So, if you have a parent container that’s 400px wide, a child element given a width of 100% will also be 400px wide, and will still be subject to margins, paddings, and borders — on top of the 100% width setting.

This is just one of those things in CSS that seems easy to understand (and really, it should be), but it’s sometimes not — because of the way that percentages work in CSS.

In the "When sending message, automatically" section, uncheck "Place a copy in."

Click Done, sign in with your Google account if prompted and that's all!

The ticket which tracks issues using Gmail with Thunderbird (Bug 402793)

So if you subscribe to both Inbox and All mail you are in practise downloaded your mails twice. If you then delete a mail in inbox it doesnt go away in All mail. It just get the trash-tag. In my opinion you should never subscribe to All mail. You never need to see it. All you need to see are INBOX, TRASH, SENT and the folders YOU created in your gmail-account.

Thunderbird determines connection details (such as ports, server names, security protocols, etc.) by looking up your email provider in a database that contains connection information for all the major Internet Service Providers (ISPs). After determining the provider of your account (as specified after the "@" symbol in your email address) Thunderbird can usually provide the account details.

Google/gmail calls apps that don't support OAuth2 "less secure". But, that doesn't make them insecure. So what it means is gmail's meaning of LessSecureApp is basically anything that doesn’t use OAuth2.

When you initially logon with OAuth2, you will be redirect to Google’s sign-in page,. Once you have signed in, Google issues you a special OAuth2 token which is saved in Thunderbird and can be seen in the same place as passwords. So when you next logon to gmail, it is using that unique OAuth ID instead of password.

No longer depends on:

Thunderbird provides the ability to archive messages - that is, to move them from the default folders to archive folders without deleting the messages altogether. This makes it easy to organize archives or move them to a backup device, and keep the Inbox clean. Messages can only be archived manually, not automatically.

Mailspring isn't VC funded and doesn't need to make millions to succeed. Just a thousand paid subscriptions will make Mailspring a stable business and we have big ideas for the future of email.

Even if you didn't intentionally make any changes, please check that this setting is enabled.

If there is still a problem, try clearing Captcha again.  I acknowledge you wrote that you already did this, but you must open that page using the account that you are setting up in Thunderbird.  If you are signed into multiple Google accounts, the page will open with the primary account.  To be certain that you have used the correct account, please try again after signing out.

Cryptocurrencies are not only an apocalyptic ecological disaster

are also incredibly toxic to the open web, another ideal that Mozilla used to support

“Money corrupts; bitcoin corrupts absolutely. Disregarding all of bitcoin's shortcomings, a financial instrument that brings out the worst in people—greed—won't change the world for the better.” —https://www.cynicusrex.com/file/cryptocultscience.html.

The highest rating Pure Health Fungus Eliminator got on Amazon is 4.0/5 stars. Meanwhile, it got 4.9 stars out of 5 on its official website. I’m not saying that the higher rating is entirely biased. But I just think that we get to see more honest reviews outside its site.

I wish there's some kind of an optional ghost or something that I can follow after a while to teach me why I cannot get past a certain area.

For example, given a website's normal communication method is the internet, out-of-band communication may be by a voice call.

Out-of-band communication may even be by beeps from the PC speaker on the server's Motherboard.

Your character feels nigh impossible to control - you move very very fast, but if youre in the air, you dont stop moving the moment you stop holding a direction, so you have to constantly cancel out your momentum to stop, but if you dont do it perfectly you suddenly fly in the other direction

TLDR: Amateur and poorly executed "Qix" type arcade game. Play Lightfish instead. It uses the same core concept but executes much better.http://store.steampowered.com/app/116120/Lightfish/E

I bought this game in order to review it, seeing as there were no current reviews for it. I thought I'd help the game out by maybe giving it that tiny bit of publicity it needed to get off the ground.

This is the kind of game that, if the quality was better, I might give it a maybe, if Steam offered one.

A good riddance from the ultra realistic modern 2021 games . Or maybe its my personal opinion that most games towards the better side should be like 16-bit only. It certainly took me back to the era of Nintendo when I frankly used to enjoy gaming the most. The look and feel of Tobe's quite resonates with good old konami games, Contra, adventure island, Super Mario, Circus Charlie, Dangerous Dave.

Hardcorps

It seems like it could be a good game but its really poorly executed,

Unique concept that could have end up as a great game, but sadly got destroyed by lack of polish .

Code that is per-component instance should go into a second <script> tag.

A plumber was a man who used lead for many reasons. Since lead was very malleable and had a low melting temperature it was employed quite a great deal to seal and repair.Pipes used to be connected and secured just as they are at present, although now we use plastics or ceramics.

One may think that the pipes leading to the sink, and the job of installing or maintaining them is described as plumbing since pipes were previously made with lead and the Latin word for lead was plumbum (consequently the elemental letters Pb).While this fact is absolutely valid, it is additionally true that plumbers were once employed in additional ways than installing pipes when the phrase plumber originally became popular in French then English within a century around the 14th Century A.D.

Furthermore, lead is very weighty and so it was often used in the role of a weight. At the end of a twine hung to be certain of a perpendicular line it is described as a plumb bob. Persons in charge of water workings earlier than the era of dependable pressure systems had to fall back on on gravity defined methods and so accurate lines and levels were essential.

.pgpass does not define a default database. It only provides the passwords for a combination of hostname, database and username.

But he has a special ability - TIME SLOWS DOWN WHEN HE MOVES.

The diagram raises an interesting question which you may not have thought about before. How does all the information from the internet get to the right device inside the network? If you visit howtogeek.com on your laptop how does it end up on your laptop and not your son’s desktop if the public-facing IP address is the same for all devices? Advertisement pagespeed.lazyLoadImages.overrideAttributeFunctions();tmntag.cmd.push(function(){tmntag.adTag('purch_Y_C_0_1', false);}); This is thanks to a wonderful bit of routing magic known as a Network Address Translation (NAT).

the whole language is a shame, but it's so useful :)

If you're using bash, you don't need to use sed to do string replacements (and it's much cleaner to use the replace feature built into bash).

We tag and release gems according to the Semantic Versioning principle. As a result of this policy, you can (and should) specify a dependency on this gem using the Pessimistic Version Constraint with two digits of precision.

Nested contexts tags are overwritten not merged: TestProf::LetItBe.configure do |config| config.default_modifiers[:freeze] = false end context "with reload", let_it_be_modifiers: {reload: true} do # uses freeze: false, reload: true here context "with freeze", let_it_be_modifiers: {freeze: true} do # uses only freeze: true (reload: true is overwritten by new metadata) end end

config.define_derived_metadata(let_it_be_frost: true) do |metadata| metadata[:let_it_be_modifiers] ||= {freeze: true} end

Thus it's not easy to refactor existing tests which use let/let! instead.

It's well-suited for dev/test since it doesn't need an external infrastructure, but it's a poor fit for production since it drops pending jobs on restart.

declaration accepts: | null | [] | [null] | [{foo: 'BAR'}] ------------------------------------------------------------------------ [Vote!]! | no | yes | no | yes [Vote]! | no | yes | yes | yes [Vote!] | yes | yes | no | yes [Vote] | yes | yes | yes | yes

[Vote!]! means that the field (in this case votes) cannot return null and that it must resolve to an array and that none of the individuals items inside that array can be null. So [] and [{}] and [{foo: 'BAR'}] would all be valid (assuming foo is non-null). However, the following would throw: [{foo: 'BAR'}, null] [Vote]! means that the field cannot return null, but any individual item in the returned list can be null. [Vote!] means that the entire field can be null, but if it does return a value, it needs to an array and each item in that array cannot be null. [Vote] means that the entire field can be null, but if it does return a value, it needs to an array. However, any member of the array may also be null.

I could look into this more to understand where things are going wrong, if you can suggest to me which part of the way this is working might be off.

Besides that configuration, SvelteKit is just a normal Vite project that does rendering on both SSR and client-side.

Two wrongs don't make a right We should fix it in popper core. I sent a PR there: floating-ui/floating-ui#1342

Just import it the normal way. Then Vite can use the CJS version on the server-side and ESM version on the client-side. Forcing it to always be ESM breaks SSR with the latest SvelteKit.

The code isn't going back to the way it was So otherwise you'll be stuck on an old version forever...

Deeply importing Svelte components is not supported. Either import all components from one entrypoint, or always stick to deep imports, otherwise it could cause multiple instance of the Svelte library running.

So, underscores are not quite as good as spaces. They’re a compromise of language, readability, and semantics, but they’re the best we’ve got. Better than dashes, CamelCase, plus+signs, or anything else. So use them.

The “use spaces, or else fall back on quotes” system is just silly.

This post is like a year old... Does not matter ,

It allows you to access common components and utility modules without ../../../../ nonsense.

The difficulty is that the square brackets accessor doesn't allow a straightforward way to access items from the end of the array, and also doesn't accept a negative index.

function intersperse<T>(this: T[], mkT: (ix: number) => T): T[] { return this.reduce((acc: T[], d, ix) => [...acc, mkT(ix), d], []).slice(1); }

you might consider using Object.defineProperty to ensure the property is not enumerable:

A Map of root-level context key-value pairs to supply to the component

Tip for those who run into the same error message and find this bug report by Google: Your cause for this error message might be a different cause entirely. To find your cause, set a breakpoint, and look at the call stack.

We couldn't see the cause due to the horrific error message from Sapper. grr at Sapper.

Moving to devDependency worked, but why?

This means that underscores allow humans to be able to space out the words used, but computers lack the ability to do so.

This is because using hyphens instead of underscores makes it easier for Google’s web crawler to compute the information that your website has and create consistent results.

The product may not be compatible with routers or gateways with firmware that has been altered, is based on open source programs, or is non-standard or outdated

Just FYI, there is a nice way to "expect a change" in RSpec. You don't have to use it, what you have is fine, just thought I'd share. expect { widget.paper_trail.update_columns(name: "Bugle") }.to(change { widget.versions.length }).from(1).to(2)

I'd prefer a "guard clause" here. return unless enabled?

TylerRick commented

Wait, I'm still interested in a solution to this problem/need! (no activity doesn't necessarily = no interest. I totally understand if the maintainers just aren't interested in implementing this and would rather someone submit a PR... but would it have been any different if I'd pinged this thread every 5 months to show continued interest? )

To be more clear, it violates this particular rule.

For what it's worth, accessing attributes with [] is not the same as using send. The latter will call the accessor method, which is what you want 99/100.

The decision to use a "keep it clean" design for the user interface sometimes takes it a step too far.

The props used for each slot inside the Tooltip. Note that componentsProps.popper prop values win over PopperProps and componentsProps.transition prop values win over TransitionProps if both are applied.

If you want to restore the old behavior (thus not reaching level AA), you can apply the following diff: -<Tooltip> +<Tooltip disableInteractive> # Interactive tooltips no longer need the `interactive` prop. -<Tooltip interactive> +<Tooltip>

In order to work with Safari, you need at least one display block or flex item below the tooltip wrapper.

A co-operative card game about assembling flat-pack furniture with your partner, and definitely not about your collapsing relationship.

make you more prepared for spontaneous things in life, like when you get asked a question in the middle of nowhere, your brain usually freezes up and can't think of an answer. This game captures that entirely.

trying to counter the antivaccine movement predicted that antivaxxers would publicize and weaponize reports of death and adverse events after COVID-19 vaccines to give the impression that the vaccines are dangerous

When the embedded document has the same origin as the embedding page, it is strongly discouraged to use both allow-scripts and allow-same-origin, as that lets the embedded document remove the sandbox attribute — making it no more secure than not using the sandbox attribute at all.

Its good to know how to implement it. I would prefer to use a gem myself.

Fixing with containIf we give each article the contain property with a value of content, when new elements are inserted the browser understands it only needs to recalculate the containing element's subtree, and not anything outside it:

I’m talking about the adults flocking to school board meetings to protect children from the manufactured crisis of “critical race theory.”

There is so much good stuff going on here.

What a time to be alive!

The complex typewriting effect is abstracted away in a neat function, out of site and out of mind.

this action is re-usable. Anytime you want a typewriter effect added to an element, you just import the function and apply it. So elegant.

All that is left is use:typeWriter. You instantly understand what it does and so will probably any future colleagues.

Some call them the lifecycle methods of elements which I think is an apt description.

Actions are deceptively simple yet incredibly powerful.

Yep, we experimented with this, but what we found is that you loose most of Svelte's niceness like slots, and instead you'll pass around deeply nested objects.

Now this is getting too complex for discussing this here and these type of architectural decisions require more in depth understanding than what I can provide here.

My UIs are data/store driven. The UI is just a way to visualize the data. Your data could flow through all of of the extensions and the extensions can make decisions (e.g. setting visible to false). Like middlewares in a Connect/Express/Polka app. And the UI doesn't even know about all this, it just updates with the current state and makes sure it's consistent.

(you can get pretty far with <svelte:component> and passing component constructors around and spicing up props along the way)

Abstract the whole queryCommandState / execCommand system into a store (or some wrapper that also holds a store) that has state like isBold and canMakeBold and a makeBold() function.

You sure packed lot of good lessons and important concept explanations/illustrations into this little answer/tutorial. Well done.

The consumer component will barely change from our last example. The only difference is the way we'll get a reference to our store (since now the store is exported from the JS module):

In effect, the $ syntax we've seen above will actually setup a subscription to the store. And the subscription will be cancelled when the component is destroyed. If the store is subscribed by multiple components, the store will be disposed only when the last component unsubscribes (it will be reinitialized, if a new subscription is made). This is very handy to manage the lifecycle of disposable things in your code.

<!-- you can use the $ prefixed value directly in the template --> <!-- (so we actually don't need the reactive expression above, in this example)

lifecycle is also managed automatically by Svelte

(And we've covered 75% of the store topic... They're efficient, to the point... And simple!)

Now your whole WS logic can be encapsulated in your JS module. That makes for good separation of concern.

In order to use this, we need to use a little more advanced readable store. Here's your example updated for this:

In your Svelte component, you can then use your store with the special $ prefix syntax, to access the value of the store ('cause the temperature variable is a reference to the store itself, it's just a mean to our end, the result we need is the value):

// our temperature is now a store with initial value 0 const temperature = writable(0); // now we don't need to change this function, the change will be propaged // by the store itself const getTemperature = () => { return temperature; }

Here's how we would rewrite our callback example with a store instead:

Same as our callback example, except they offer a handful of other very useful tool (like computing derived values from other stores), and also a slick syntax in the Svelte component.

Stores are essentially some kind of simplified streams (or Observable as they're called in ES), that is they represent a value over time.

Stores are the idiomatic Svelte way when you need to import "reactivity" from your normal JS sources.

If you need to pass multiple arguments to an action, combine them into a single object, as in use:longpress={{duration, spiciness}}

Personally, I prefer an event-based communication, but I don't think it's actually better. The only problem with props is that it can cause problems if badly managed, but normally, both of them are ok. In real life, I would opt for storage.

Interim summary

Finally, I think Actions are great for animations, because you will definitely need to apply the same logic to many different elements. One of my favorite examples are FLIP animations, where a change in DOM position can be animated. For example shuffling a list of items. I will not dive deep into the topic in this article: I've written about some techniques in this article about FLIP animations in React and in this article about how to create spring animations with Web Animation API. Although they are not about Svelte, at the end of the day it all boils down to manipulating the HTML element directly. And Svelte Actions are a great place to do it.

We also need at least something in our CSS that can be set from outside. CSS custom properties are a great fit for this!

But you can get quite close to directly updating CSS with Actions!

export function autofocus(node) { node.focus(); } That's it. This is a legitimate Svelte Action!