The inputmode global attribute provides a hint to browsers for devices with onscreen keyboards to help them decide which keyboard to display when a user has selected any input or textarea element.

<input type="text" inputmode="" />
<textarea inputmode="" />

Unlike changing the type of the form, inputmode doesn’t change the way the browser interprets the input — it instructs the browser which keyboard to display.

The inputmode attribute has a long history but has only very recently been adopted by the two major mobile browsers: Safari for iOS and Chrome for Android. Before that, it was implemented in Firefox for Android way back in 2012, and then subsequently removed several months later (though it is still available via a flag).

Almost six years later, Chrome for Android implemented the feature — and with the recent release of iOS 12.2, Safari now supports it too.

But before we go deep into the ins and outs of the attribute, consider that the WHATWG living standard provides inputmode documentation while the W3C 5.2 spec no longer lists it in its contents, which suggests they consider it obsolete. Given that WHATWG has documented it and browsers have worked toward supporting it, we’re going to go assume WHATWG specifications are the standard.

inputmode accepts a number of values. Let’s go through them, one by one.

None

<input type="text" inputmode="none" />

We’re starting here because it’s very possible we don’t want any type of keyboard on an input. Using inputmode=none will not show a keyboard at all on Chrome for Android. iOS 12.2 will still show its default alphanumeric keyboard, so specifying none could be sort of a reset for iOS in that regard. Regardless, none is intended for content that renders its own keyboard control.

Numeric

<input type="text" inputmode="numeric" />

This one is probably the one of the more common inputmode values out in the wild because it’s ideal for inputs that require numbers but no letters — things like PIN entry, zip codes, credit card numbers, etc. Using the numeric value with an input of type="text" may actually make more sense than setting the input to type="number" alone because, unlike a numeric input, inputmode="numeric" can be used with maxlength, minlength and pattern attributes, making it more versatile for different use cases.

I’ve often seen sites using type=tel on an input to display a numeric keyboard, and that checks out as a workaround, but isn’t semantically correct. If that bums you out, remember that inputmode supports patterns, we can add pattern="d*" to the input for the same effect. That said, only use this if you are certain the input should only allow numeric input because Android (unlike iOS) doesn’t allow the user to change to the keyboard to use letters, which might inadvertently prevent users from submitting valid data.

Tel

<input type="text" inputmode="tel" />

Entering a telephone number using a standard alphanumeric keyboard can be a pain. For one, each number on a telephone keyboard (except 1 and 0) represents three letters (e.g. 2 represents A, B and C) which are displayed with the number. The alphanumeric keyboard does not reference those letters, so decoding a telephone number containing letters (e.g. 1-800-COLLECT) takes more mental power.

Using inputmode set to tel will produce a standard-looking telephone keyboard, including keys for digits 0 to 9, the pound (#) character, and the asterisk (*) character. Plus, we get those alphabetic mnemonic labels (e.g. ABC).

Decimal

<input type="text" inputmode="decimal" />

An inputmode set to the decimal value results in a subtle change in iOS where the keyboard appears to be exactly the same as the tel value, but replaces the +*# key with a simple decimal (.). On the flip side, this has no effect on Android, which will simply use the numeric keyboard.

Email

<input type="text" inputmode="email" />

I’m sure you (and at least someone you know) has filled out a form that asks for an email address, only to make you swap keyboards to access the @ character. It’s not life-threatening or anything, but certainly not a great user experience either.

That’s where the email value comes in. It brings the @ character into the fray, as well as the decimal (.) character.

This could also be a useful keyboard to show users who need to enter a Twitter username, given that@ is a core Twitter character for identifying users. However, the email address suggestions that iOS display above the keyboard may cause confusion.

Another use case could be if you have your own email validation script and don’t want to use the browsers built-in email validation.

URL

<input type="text" inputmode="url" />

The url value provides a handy shortcut for users to append TLDs (e.g. .com or .co.uk) with a single key, as well keys typically used in web addresses, like the dot (.) and forward slash (/) characters. The exact TLD displayed on the keyboard is tied to the user’s locale.

This could also be a useful keyboard to show users if your input accepts domain names (e.g. css-tricks.com) as well as full URIs (e.g. https://css-tricks.com). Use type="url" instead if your input requires validating the input.

Search

<input type="text" inputmode="search" />

This displays a blue Go key on iOS and a green Enter key on Android, both in place of where Return. As you may have guessed by the value’s name, search is useful for search forms, providing that submission key to make a query.

If you’d like to showSearch instead of Enter on iOS and a magnifying glass icon on Android in place of the green arrow, use type=search instead.

Other things you oughta know

• Chromium-based browsers on Android — such as Microsoft Edge, Brave and Opera — share the same inputmode behavior as Chrome.
• I haven’t included details of keyboards on iPad for the sake of brevity. It’s mostly the same as iPhone but includes more keys. Same is true for Android tablets, save for third-party keyboards, which might be another topic worth covering.
• The original proposed spec had the values kana and katakana for Japanese input but they were never implemented by any browser and have since been removed from the spec.
• latin-name was also one of the values of the original spec and has since been removed. Interestingly, if it’s used now on Safari for iOS, it will display the user’s name as a suggestion above the keyboard.

  

Demo

Oh, you want to see how all of these input modes work for yourself? Here’s a demo you can use on a device with a touchscreen keyboard to see the differences.

References

• WHATWG specification
• MDN documentation
• Caniuse
• Chrome Platform Status (Chromium Ticket #244688)

The post Everything You Ever Wanted to Know About inputmode appeared first on CSS-Tricks.

Šime posts regular content for web developers on webplatform.news. Each week, he covers timely news at the intersection of development standards and the tools that make them available on the web.

Installed PWAs cannot easily be restarted on iOS

iOS 12.2 PWAs
? In-App browser for external content (OAuth)
? New lifecycle (No Reload)
?Navigation gestures
?WebShare
??Motion Sensors disabled; old getUserMedia removed
? IntersectionObserver, ConicGradients, datalist, color picker, AbortFetchhttps://t.co/LNzq6MzqjR

— Maximiliano Firtman @ ?? Vilnius (@firt) March 26, 2019

Maximiliano Firtman: On iOS, it is not possible to restart an installed PWA by closing it from the recently used apps screen and then immediately reopening it. Instead of restarting the app, iOS restores its state. This can be a problem for users if the PWA gets stuck in a broken state.

with type ‘file’ bug on #iOS 12.2 #PWA
Open the input, put the PWA in bg by pressing home button. The input stops working. True for any input with type ‘file’ throughout the app. It works after a phone restart. pic.twitter.com/IfzsXy91RK

— Pankaj Nathani ?? (@croozeus) April 11, 2019

After some undefined time, the saved context seems to disappear. So if you get out of the PWA, do nothing with your phone and wait some hours to go back to the PWA, it restarts from scratch.

Instilling a performance culture at The Telegraph

We’ve been working hard at The Telegraph to improve third-party performance. Here is an insight into our approach – https://t.co/4hhRDYaidS #webperf ??

— Gareth Clubb (@digitalclubb) April 30, 2019

Gareth Clubb: At The Telegraph (a major UK newspaper), we set up a web performance working group to tackle our “organizational” performance challenges and instill a performance culture. The group meets regularly to review third-party tags and work on improving our site’s performance.

We’ve started deferring all JavaScript (including our own) using the attribute. This change alone nearly doubled our (un-throttled) Lighthouse performance score.

Deferring our JavaScript hasn’t skewed any existing analytics and it certainly hasn’t delayed any advertising. […] The First Ad Loaded metric improved by an average of four seconds.

We also removed 1 MB of third-party payload from our new front end. When one of our teams requests the addition of any new script, we now test the script in isolation and reject it if it degrades our metrics (first contentful paint, etc.).

When we started this process, we had a collection of very old scripts and couldn’t track the original requester. We removed those on the premise that, if they were important, people would get back in touch?—?no one did.

Microsoft plans to add tracking prevention to the Edge browser

Kyle Pflug: Microsoft has announced plans to add options for blocking trackers to the Edge browser. Malicious trackers would be blocked automatically, and the user would have the option to additionally block all potential trackers.

This would make Edge the fourth major browser with some form of built-in anti-tracking feature (two other major browsers, Opera and UC Browser, include ad blockers instead).

1. In 2015, Firefox added Tracking Protection?—?recently renamed to Content Blocking?—?becoming the first major browser to protect users from third-party trackers (when browsing the web in private mode).
2. Since 2017, Safari prevents cross-site tracking by default, through a feature called Intelligent Tracking Prevention (ITP). Users are prompted to allow tracking when they try to interact with third-party widgets on websites.

   

3. Earlier this year, Samsung Internet added an experimental feature called Smart Anti-Tracking that denies third-party trackers access to cookies.

The post Weekly news: PWA Issue on iOS, Performance Culture, Anti-Tracking in Browsers appeared first on CSS-Tricks.

Presentation speaks volumes. A post or a presentation with an impeccable design is deemed to be catchy in comparison to texts.

When the text fails to catch the attention of a buyer, it is the image that does the magic. However, the importance of design and visuals is often neglected in marketing. According to research, typography helps in influencing human minds greatly with high retaining capacity.

Getting to the minds of the audience is one tricky thing. No matter how impeccable of an idea you may be having, if you are unable to reach it out to the audience, it is a failure. And this very aspect of conceptualizing the idea and turning it into a marketing tool is where lies the major challenge. This is where designing does its magic.

Yes, you heard it right. While Marketing and Advertising do play a major role in terms of strong copywriting, and promotion, it is the design that plays a critical role in upscaling any campaign. The marketing strategy must not only be focussed on how to generate result but also watch out on how the business can reach to the audience and generate high ROI.

Herein we have enlisted the various advantages of design and how It can help in increasing the sales of a brand:

It helps in communicating a brand

Marketing campaigns and advertisements are all about raising the profiles of brands as well as convincing the customers in buying the company’s product or service. Brands play an essential role in fixing the offerings of companies into the minds of the target audience. More creative the campaign more the chances lie for customers in buying the product. Herein, whether it’s a creative blog, brochure or an image it indirectly aids in talking about the product. And hence it must be impeccable.

However, in comparison to wholly textual data, visuals penetrate into the minds of consumers easily. If the design is less professional and only speaks about the brand’s core messaging it will fail in creating a good impression and undermine its credibility. Hence, using the right quality, texturing and colors are essential aspects to consider for communicating a brand to the target audience.

It attracts the attention of the consumer

If you want to be successful, you must be able to stand out of the crowd. This means coming up with impeccable and out of the box ideas which is different in comparison to other brands. Your marketing campaign will fail to create the magic in it cannot raise a noise above that of other contemporaries who are also competing for a brand same as that of yours.

Thus, the design must try to meet the goal of the campaign in a proficient and finesse manner. The design must be hard-hitting that gets fixed in the mind of the customers over other advertisers.

For example – if you are talking about a health drink, you must use the perfect colorations and design which can create an impact in the minds of the consumers. Great design works as the voice of advertisers which helps one speak about the prospects in a memorable manner making it get noticed.

It aids in converting the potential audience into sales

In marketing, one must foremost be able to understand the psychology of the customers. If your client speaks about conversions, all it means is call to action. Often advertisers fail in this aspect wherein they are unable to determine how psychologically compelling design can be and how it can help in converting sales into profits.

Suppose you visit a website, what is the first thing in which your eyes fall? Is it the writing or the layout? What emotions do the photographs, colors, and use of layouts evoke? This is one such area that stands out in comparison to others. A design that is well crafted and created can masterfully craft your pitch or else pull it down in the gallows of conversion.

It helps in reinforcing the message

Good design never underplays in the game of getting noticed. It offers the best platform in conveying what the marketers wish to divulge or inform the audience. This very aspect invokes the argument on the importance of designing in marketing as well as branding on how it can powerfully evoke a message in the minds of the consumer. One need not need a set of wordings to convey an idea, a few sets of images can do the magic.

For example – In case you run a nonprofit organization. The possibility of conveying the cause is more when one chooses a few images either in animation or photographs than writing hundreds of words of copy on the same issue.

What are the elements of designing?

The designer must be knowledgeable and carry some substance surrounding the intricacies of designing. These include the use of the right color combination, texturing and typography. All these elements play an equal role in making the image stand out.

Some of the elements of designing that can make the image stand out includes:

Colorations and shades

Each color speaks a language of their own. Using the right color combination in the perfect place is an important criterion.

For example – Using a red color for love, green color for brands about health, nature, purple for showing the richness, etc. are few aspects a designer must keep a note about when developing the image.

Positioning

The image must be focused on the central character that is your brand without taking away the essence of it. The consumer’s eyes must first fall on the brand rather than wander all across the image. Thus, using minimum typographies and other elements is yet another important aspect.

Symmetry

The image must be symmetrical, this means all the elements used in the image must not be placed in a haphazard manner. They should be in sync with one another relating to each other. In short, the design or image must be able to convey the story without speaking about it loudly through words.

The right balance of idea, design, and conceptualization is the key factor of increasing sales without using words.

Designing an interactive interface or a website is not an easy feat. You have to analyze everything about your audience, in the first place their behavior, and then implement thorough planning. New technologies are making it easier but they are also making the users more tech savvy and hard to impress.

Glossy images and hover effects are no longer impressive to users. Neither are animations or gifs – especially when everyone can make their own in just a few steps with their phones. So, how do you go about creating a great experience for your users? How do you make them happy and keep the conversions coming?

This is only getting harder if you make mistakes in your design in order to impress your audience. So, without further ado, here are some of the mistakes designers commonly make in order to amaze visitors:

1. Innovating Too Much

Design, in itself, is a creative endeavor. Designers are artists in their own respect and they always seek to express themselves through their work. They are always innovating and making sure that their designs stand out in the sea of other designs.

But if we are talking about designing a perfect interactive experience for your users, innovation might not always be the best choice. It might not be good for the niche or even that specific website. Users need to feel comfortable when visiting a website. They need that familiarity in the ways that they work with a website — you know, the common navigation patterns. They are very used to this and going off track in order to be clever or unique can only harm you, especially if you go too far.

For instance, you may have a great project in mind, some gamification methods for example, however, if you stray too far into the unknown the user will stumble onto your website, see the thing and just walk away because they won’t know what to do with it. Especially so if they are seeking just some basic information.

2. Confusing Navigation

This is a mistake we see all too often. So many websites start out as great experiences and then mess everything up with poor navigation. Some go for strange navigation places where users won’t think to look.

And yet the biggest problem users have is not that — it’s all the weird names for common pages. So, instead of the simple and sufficient “home, about, contact, blog” pattern, you get “our universe, the theory of an artist, follow your stars, always learn more”, for instance.

The thing is that users will appreciate the creativity in naming — at some point, if they manage to figure out what name is for what. It takes them a lot of browsing to find what they need. Keep in mind that most users are not there to marvel at your skill in designing but rather to find information they need to contact the company or learn more about what they have to offer. And the very purpose of the design is to allow them to do so quickly and simply, without wandering about for too long. If they do, they will probably leave the site and then the purpose of design is defeated.

3. Hating White Space

Once upon a time, sticking as many things as possible on your website was a trend. You had boxes of information all around the place, advertisements and much, much more. But that was then and we have moved (thankfully) far, far away from that. Simplicity is in. Zen is in. Users don’t want to be overwhelmed when they enter your website. They want a clear and streamlined experience that will give them what they need.

And yet, many websites still make the mistake of cluttering, thinking that they are actually not. But, you see, sticking to a single color scheme is fine but you need to think about other elements too. Having too much information on any page will have your readers running away. It also looks very, very spammy, no matter how much you want to promote.

So, nail the basics first. Then move on to creating something impressive to look at and interact with.

4. Not Using Contrast

Honestly, without contrast – what is there left?

It’s so important to use it to establish that visual hierarchy and move the user’s attention to the places where you want them to. It’s not just colors, it’s sizes, shapes, placement. Everything on a single website needs to be in contrast to another thing to show its value and importance in a subtle way.

People automatically understand that the smaller button is less important than the bigger button. They understand that the bigger letters or more emphasized letters are more important

~ Donald Emerson, an design blogger at Writemyx

So, make sure that your design has plenty of contrast to show the user where to go and what to do.

5. Complex Forms

Forms are a pain for everyone. No one likes to fill them out. But, they are also a necessary evil if you want to get consumer data to use for further endeavors.

However, they don’t need to look ugly and be annoying. What leads to this? Well, for one, long forms that ask for too much. The user might go through with the form if they care enough. But in most cases, they don’t — especially not enough to do “where is the bus?” captchas — so, eliminate that ugly form and go for something simple and stylish.

Stick to the simple – first name, last name, email (add more basics if you need, like password, for instance) or even better, first name, email. Don’t ask for too much. And, for the love of design, test the thing. Some forms on the web ask for too much “optional” information but then when you opt out, they highlight all of the blank spaces and refuse to submit without them. Not really optional.

So, when it comes to design, it’s important to think of the user and efficiency first and then find ways to delight them without confusing them. Test everything. This is the key to having a design that’s both successful and pretty.

Featured image via DepositPhotos.

Source

How do you understand when a graphics project is effective? When it’s nice or ugly? Should it be “cute”? Should it be “fashionable”? In short: how do you assess the quality of a project? In this article I really want to talk about this topic, and try to explain how you to really evaluate the quality of a project. In an objective way. Let’s jump right into it!

How do you evaluate the quality of a project in graphic design?

When evaluating the quality of a design project, the subjective aspects and personal tastes certainly play an important role. But it is important to ensure that the evaluation of a project does not depend solely on those two things. In fact, in graphic design, a project is created to communicate a message and get specific results. And those are objective aspects: they do not depend on your personal tastes.

The aesthetic aspect is an important factor, but by itself, it will not tell you if the design is effective or not. To know if your project is a winner, you need to consider the elements of good visual communication and judge the project with respect to them. Well, keeping these things in mind, here are some questions you should ask yourself when evaluating the quality of design.

How to assess the quality of a project: the 4 questions to be asked

1. Does your project achieve its goals?

Let’s start with the basics: what are the goals of the project you are working on? Understanding the objectives of a project is a fundamental step in any graphic design project. This should always be your first step. A good way to understand them is to do a good design brief. We can talk specifics on a design brief another time. For now, let’s keep this train rolling. But what does understanding goals mean?

If it is a logo, for example, that logo aims to represent and communicate a corporate identity. If it’s the landing page of a website, instead, maybe the goal is to convince users to click on the “Buy” button or sign up for a newsletter. And so on. Each graphic project has a specific objective. And if it doesn’t have one, it means it’s not graphic design, but art or decoration. Always check if the target has been achieved! The first step to verify the achievement of the objectives is to make sure that all the relevant information is present to communicate the message you want to communicate.

2. Is the message easy to understand?

Every designer project must help to communicate a certain message correctly. Does your project do it easily? How about immediately? Here are some practical tips for building an effective graphic layout, in which the message is transmitted immediately:

Use a focal point on the page. Such as a large text or a title. Something that catches the viewer’s attention. The important thing is that attention goes to an important and useful element to convey the message. Then choose the focal point carefully!

3. Is it aesthetically pleasing?

Design is made to solve problems through visual solutions. But if those solutions are pleasing to look at, as well as functional, you double the strength of what you communicate, right? Is your project pleasant? Looking good? This is probably the most subjective part of evaluating graphic design. What is appealing to one person might be horrible for another. Different minds, different opinions.

However, generally, already applying the principles of graphic design, one can obtain excellent results in terms of aesthetics. Doing something beautifully does not necessarily mean doing something extremely different from what it already is. Because the result of something deliberately “different” could be too extravagant in the end.

Paul Rand, one of the most important twentieth-century logo designers, said: “Don’t try to be different, try to be good.” Wiser words have perhaps never been spoken. So try to do something that works, even if maybe it’s not something radically different from everything you’ve seen before (which is practically impossible, actually).

Are the aesthetic style and the graphic elements used suitable for the target audience? Most of the time you’re not just planning for yourself, but you’re trying to create a design that appeals to a particular audience. A rainbow color palette is not suitable for a finance website because most customers are looking for a consultant who is reassuring, loyal and trustworthy. Therefore, a more moderate and sober tone may be more appropriate. On the contrary, research shows that children prefer bright colors, so it makes more sense to turn to bright and over the top colors when it comes to children.

4. Is your project original?

Not different in the sense that we have never seen anything like it before, but different in the sense of creativity. The meaning of “originality” depends on the type of design you are dealing with. If it is a logo, it is better to make sure it is as unique as possible, because it is necessary to be able to register the trademark and the trademark application will be rejected if you use a copy of a design. An example of difficulties that can arise from logos that are too similar: the ongoing cause between 3M and Formula 1. It is difficult to create a logo with a simple and distinctive design that does not resemble any other existing design because so many ideas have already been taken and registered as trademarks. If a designer creates a logo that looks similar to an existing design, it’s not necessarily because he copied it, but because there are some logo concepts that are really common and that can be achieved regardless of seeing those designs.

This is why it is necessary to research other designs in your market and avoid designs that are too generic. However, in reality, beyond the logo, the true differentiation of a company over another is in the management of the brand and the complete coordinated image. When instead we talk about simpler elements, like the business card, differentiating oneself is something not very sensible and useless.

Good design is useless if it communicates something wrong

Good design can do great things for a business, but it will not work miracles. It doesn’t matter how good your job as a designer is if the company communicates to the wrong audience. A good design will not be effective if the product is poor or the communication is inadequate, and in the same way, a bad sales performance is not always a consequence of the quality of the design.

There are many ways to measure the performance of a project in the real world, such as A / B tests for web pages, product focus groups, results in social media interactions or sales. However, not everyone can test a project before putting it on the market. In most cases, the customer will trust your judgment. So it is essential that you develop a critical sense of analysis of your work and your projects. Let’s not reinvent the wheel here, maybe just try another way to use it.

Read More at How do you evaluate the quality of a project in graphics?

In a perfect world, our projects would have unlimited resources and time. Our teams would begin coding with well thought out and highly refined UX designs. There would be consensus among developers about the best way to approach styling. There’d be one or more CSS gurus on the team who could ensure that functionality and style could roll out simultaneously without it turning into a train-wreck.

I’ve actually seen this happen in large enterprise environments. It’s a beautiful thing. This article is not for those people.

On the flip side of the coin is the tiny startup that has zero funding, one or two front-end developers, and a very short timeline to demonstrate some functionality. It doesn’t have to look perfect, but it should at least render reasonably well on desktop, tablet, and mobile. This gets them to a point where it can be shown to advisors and early users; maybe even potential investors who’ve expressed an interest in the concept. Once they get some cashflow from sales and/or investment, they can get a dedicated UX designer and polish the interface.

What follows is for this latter group.

Project Kickoff Meeting

Let’s invent a company to get the ball rolling.

Solar Excursions is a small travel agency aiming to serve the near-future’s burgeoning space tourism industry.

Our tiny development team has agreed that React will be used for the UI. One of our front-end developers is big on Sass, and the other is enamored with CSS in JavaScript. But they’ll be hard pressed to knock out their initial sprint goals; there’s certainly no time for arguing about the best possible styling approach. Both coders agree the choice doesn’t matter much in the long run, as long as its consistently executed. They’re certain that implementing the styling from scratch under the gun now will incur technical debt that will have to be cleaned up later.

After some discussion, the team opts to plan for one or more “styling refactor” sprints. For now, we’ll just focus on getting something up on the screen using React-Bootstrap. That way we’ll be able to quickly build working desktop and mobile layouts without much fuss.

The less time spent on front-end styling the better, because we’ll also need the UI to hook up to the services our backend developer will be cranking out. And, as our application architecture begins to take shape, both front-enders agree it’s important that it be unit tested. They have a lot on their plate.

Based on my discussions with the Powers That Be, as a dedicated project manager, I slaved over Balsamiq for at least ten minutes to provide the team with mockups for the booking page on desktop and mobile. I assume they’ll make tablet meet in the middle and look reasonable.

Sprint Zero: Review Meeting

Pizza all around! The team worked really hard to hit its goals, and we now have a booking page with a layout that approximates the mockups. The infrastructure for services is coming together, but there’s quite a way to go before we can connect the UI to it. In the interim, the front-enders are using a hardcoded mock data structure.

Here’s a look at our UI code so far:

This is all straightforward React. We’re using some of that Hooks hotness, but it’s probably passé to most of you by now.

The key takeaway to notice here is how four of our five application components import and use components from react-bootstrap. Only the main App component is unaffected. That’s because it just composes the top level view with our custom components.

// App.js imports
import React, { useState } from "react";
import Navigation from "./Navigation";
import Page from "./Page";

// Navigation.js imports
import React from "react";
import { Navbar, Dropdown, Nav } from "react-bootstrap";

// Page.js imports
import React from "react";
import PosterCarousel from "./PosterCarousel";
import DestinationLayout from "./DestinationLayout";
import { Container, Row, Col } from "react-bootstrap";

// PosterCarousel.js imports
import React from "react";
import { Alert, Carousel, Image } from "react-bootstrap";

// DestinationLayout.js imports
import React, { useState, useEffect } from "react";
import {
  Button,
  Card,
  Col,
  Container,
  Dropdown,
  Jumbotron,
  ListGroup,
  Row,
  ToggleButtonGroup,
  ToggleButton
} from "react-bootstrap";

The decision to move fast with Bootstrap has allowed us to hit our sprint goals, but we’re already accumulating technical debt. This is just four affected components, but as the application grows, it’s clear the “styling refactor” sprints that we planned for are going to become exponentially harder. And we haven’t even customized these components much. Once we have tens of components, all using Bootstrap with lots of inline styling to pretty them up, refactoring them to remove react-bootstrap dependencies will be a scary proposition indeed.

Rather than building more of the booking pipeline pages, the team decides that we’ll spend the next sprint working to isolate the react-bootstrap usage in a custom component kit since our services are still under construction. Application components will only use components from this kit. That way, when it comes time to ween ourselves from react-bootstrap, the process will be much easier. We won’t have to refactor thirty usages of the react-bootstrap Button throughout the app, we’ll just rewrite the internals of our KitButton component.

Sprint One: Review Meeting

Well, that was easy. High-fives. No change to the visual appearance of the UI, but we now have a “kit” folder that’s sibling to “components” in our React source. It has a bunch of files like KitButton.js, which basically export renamed react-bootstrap components.

An example component from our kit looks like this:

// KitButton.js
import { Button, ToggleButton, ToggleButtonGroup } from "react-bootstrap";
export const KitButton = Button;
export const KitToggleButton = ToggleButton;
export const KitToggleButtonGroup = ToggleButtonGroup;

We wrap those all kit components up into a module like this:

// kit/index.js
import { KitCard } from "./KitCard";
import { KitHero } from "./KitHero";
import { KitList } from "./KitList";
import { KitImage } from "./KitImage";
import { KitCarousel } from "./KitCarousel";
import { KitDropdown } from "./KitDropdown";
import { KitAttribution } from "./KitAttribution";
import { KitNavbar, KitNav } from "./KitNavbar";
import { KitContainer, KitRow, KitCol } from "./KitContainer";
import { KitButton, KitToggleButton, KitToggleButtonGroup } from "./KitButton";
export {
  KitCard,
  KitHero,
  KitList,
  KitImage,
  KitCarousel,
  KitDropdown,
  KitAttribution,
  KitButton,
  KitToggleButton,
  KitToggleButtonGroup,
  KitContainer,
  KitRow,
  KitCol,
  KitNavbar,
  KitNav
};

And now our application components are completely free of react-bootstrap. Here are the imports for the affected components:

// Navigation.js imports
import React from "react";
import { KitNavbar, KitNav, KitDropdown } from "../kit";


// Page.js imports 
import React from "react";
import PosterCarousel from "./PosterCarousel";
import DestinationLayout from "./DestinationLayout";
import { KitContainer, KitRow, KitCol } from "../kit";


// PosterCarousel.js imports
import React from "react";
import { KitAttribution, KitImage, KitCarousel } from "../kit";


// DestinationLayout.js imports
import React, { useState, useEffect } from "react";
import {
  KitCard,
  KitHero,
  KitList,
  KitButton,
  KitToggleButton,
  KitToggleButtonGroup,
  KitDropdown,
  KitContainer,
  KitRow,
  KitCol
} from "../kit";

Here’s the front-end codebase now:

Although we’ve corralled all of the react imports into our kit components, our application components still rely a bit on the react-bootstrap implementation because the attributes we place on our kit component instances are the same as those of react-bootstrap. That constrains us when it comes to re-implementing the kit components, because we need to adhere to the same API. For instance:

// From Navigation.js
<KitNavbar bg="dark" variant="dark" fixed="top">

Ideally, we wouldn’t have to add those react-bootstrap specific attributes when we instantiate our KitNavbar.

The front-enders promise to refactor those out as we go, now that we’ve identified them as problematic. And any new references to react-bootstrap components will go into our kit instead of directly into the application components.

Meanwhile, we’ve shared our mock data with the server engineer, who is working hard to build separate server environments, implement the database schema, and expose some services to us.

That gives us time to add some gloss to our UI in the next sprint — which is good because the Powers That Be would like to see separate themes for each destination. As the user browses destinations, we need to have the UI color scheme change to match the displayed travel poster. Also, we want to try and spiff up those components a bit to begin evolving our own look and feel. Once we have some money coming in, we’ll get a designer to do a complete overhaul, but hopefully we can reach a happy medium for our early users.

Sprint Two: Review Meeting

Wow! The team really pulled out all the stops this sprint. We got per-destination themes, customized components, and a lot of the lingering react-bootstrap API implementations removed from the application components.

Here’s what the desktop looks like now:

In order to pull this off, the front-enders brought in the Styled Components library. It made styling the individual kit components a breeze, as well as adding support for multiple themes.

Let’s look at a few highlights of their changes for this sprint.

First, for global things like pulling in fonts and setting the page body styles, we have a new kit component called KitGlobal.

// KitGlobal.js
import { createGlobalStyle } from "styled-components";
export const KitGlobal = createGlobalStyle`
  body {
    @import url('https://fonts.googleapis.com/css?family=Orbitron:500|Nunito:600|Alegreya+Sans+SC:700');
    background-color: ${props => props.theme.foreground};
    overflow-x: hidden;
  }
`;

It uses the createGlobalStyle helper to define the CSS for the body element. That imports our desired web fonts from Google, sets the background color to whatever the current theme’s “foreground” value is, and turns off overflow in the x-direction to eliminate a pesky horizontal scrollbar. We use that KitGlobal component in the render method of our App component.

Also in the App component, we import ThemeProvider from styled-components, and something called “themes” from ../theme. We use React’s useState to set the initial theme to themes.luna and React’s useEffect to call setTheme whenever the “destination” changes. The returned component is now wrapped in ThemeProvider, which is passed “theme” as a prop. Here’s the App component in its entirety.

// App.js
import React, { useState, useEffect } from "react";
import { ThemeProvider } from "styled-components";
import themes from "../theme/";
import { KitGlobal } from "../kit";
import Navigation from "./Navigation";
import Page from "./Page";
export default function App(props) {
  const [destinationIndex, setDestinationIndex] = useState(0);
  const [theme, setTheme] = useState(themes.luna);
  const destination = props.destinations[destinationIndex];
  useEffect(() => {
    setTheme(themes[destination.theme]);
  }, [destination]);

  return (
    <ThemeProvider theme={theme}>
      <React.Fragment>
        <KitGlobal />
        <Navigation
          {...props}
          destinationIndex={destinationIndex}
          setDestinationIndex={setDestinationIndex}
        />
        <Page
          {...props}
          destinationIndex={destinationIndex}
          setDestinationIndex={setDestinationIndex}
        />
      </React.Fragment>
    </ThemeProvider>
  );
}

KitGlobal is rendering like any other component. Nothing special there, only that the body tag is affected. ThemeProvider is using the React Context API to pass theme down to whatever components need it (which is all of them). In order to fully understand that, we also need to take a look at what a theme actually is.

To create a theme, one of our front-enders took all the travel posters and created palettes for each by extracting the prominent colors. That was fairly simple.

Obviously, we weren’t going to use all the colors. The approach was mainly to dub the most used two colors foreground and background. Then we took three more colors, generally ordered from lightest to darkest as accent1, accent2, and accent3. Finally, we picked two contrasting colors to call text1 and text2. For the above destination, that looked like:

// theme/index.js (partial list)
const themes = {
  ...
  mars: {
    background: "#a53237",
    foreground: "#f66f40",
    accent1: "#f8986d",
    accent2: "#9c4952",
    accent3: "#f66f40",
    text1: "#f5e5e1",
    text2: "#354f55"
  },
  ...
};
export default themes;

Once we have a theme for each destination, and it is being passed into all the components (including the kit components that our application components are now built from), we need to use styled-components to apply those theme colors as well as our custom visual styling, like the panel corners and “border glow.”

This is a simple example where we made our KitHero component apply the theme and custom styles to the Bootstrap Jumbotron:

// KitHero.js
import styled from "styled-components";
import { Jumbotron } from "react-bootstrap";

export const KitHero = styled(Jumbotron)`
  background-color: ${props => props.theme.accent1};
  color: ${props => props.theme.text2};
  border-radius: 7px 25px;
  border-color: ${props => props.theme.accent3};
  border-style: solid;
  border-width: 1px;
  box-shadow: 0 0 1px 2px #fdb813, 0 0 3px 4px #f8986d;
  font-family: "Nunito", sans-serif;
  margin-bottom: 20px;
`;

In this case, we’re good to go with what gets returned from styled-components, so we just name it KitHero and export it.

When we use it in the application, it looks like this:

// DestinationLayout.js (partial code)
const renderHero = () => {
  return (
    <KitHero>
      <h2>{destination.header}</h2>
      <p>{destination.blurb}</p>
      <KitButton>Book Your Trip Now!</KitButton>
    </KitHero>
  );
};

Then there are more complex cases where we want to preset some attributes on the react-bootstrap component. For instance, the KitNavbar component which we identified earlier as having a bunch of react-bootstrap attributes that we’d rather not pass from the application’s declaration of the component.

Now for a look at how that was handled:

// KitNavbar.js (partial code)
import React, { Component } from "react";
import styled from "styled-components";
import { Navbar } from "react-bootstrap";

const StyledBootstrapNavbar = styled(Navbar)`
  background-color: ${props => props.theme.background};
  box-shadow: 0 0 1px 2px #fdb813, 0 0 3px 4px #f8986d;
  display: flex;
  flex-direction: horizontal;
  justify-content: space-between;
  font-family: "Nunito", sans-serif;
`;

export class KitNavbar extends Component {
  render() {
    const { ...props } = this.props;
    return <StyledBootstrapNavbar fixed="top" {...props} />;
  }
}

First, we create a component called StyledBootstrapNavbar using styled-components. We were able to handle some of the attributes with the CSS we passed to styled-components. But in order to continue leveraging (for now) the reliable stickiness of the component to the top of the screen while everything else is scrolled, our front-enders elected to continue using react-bootstrap’s fixed attribute. In order to do that, we had to create a KitNavbar component that rendered an instance of StyledBootstrapNavbar with the fixed=top attribute. We also passed through all the props, which includes its children.

We only have to create a separate class that renders styled-component’s work and passes props through to it if we want to explicitly set some attributes in our kit component by default. In most cases, we can just name and return styled-component’s output and use it as we did with KitHero above.

Now, when we render the KitNavbar in our application’s Navigation component, it looks like this:

// Navigation.js (partial code)
return (
  <KitNavbar>
    <KitNavbarBrand>
      <KitLogo />
      Solar Excursions
    </KitNavbarBrand>
    {renderDestinationMenu()}
  </KitNavbar>
);

Finally, we took our first stabs at refactoring our kit components away from react-bootstrap. The KitAttribution component is a Bootstrap Alert which, for our purposes, is little more than an ordinary div. We were able to easily refactor to remove its dependency on react-bootstrap.

This is the component as it emerged from the previous sprint:

// KitAttribution.js (using react-bootstrap)
import { Alert } from "react-bootstrap";
export const KitAttribution = Alert;

This is what it looks like now:

// KitAttribution.js
import styled from "styled-components";
export const KitAttribution = styled.div`
  text-align: center;
  background-color: ${props => props.theme.accent1};
  color: ${props => props.theme.text2};
  border-radius: 7px 25px;
  border-color: ${props => props.theme.accent3};
  border-style: solid;
  border-width: 1px;
  box-shadow: 0 0 1px 2px #fdb813, 0 0 3px 4px #f8986d;
  font-family: "Alegreya Sans SC", sans-serif;
  > a {
    color: ${props => props.theme.text2};
    font-family: "Nunito", sans-serif;
  }
  > a:hover {
    color: ${props => props.theme.background};
    text-decoration-color: ${props => props.theme.accent3};
  }
`;

Notice how we no longer import react-bootstrap and we use styled.div as the component base. They won’t all be so easy, but it’s a process.

Here are the results of our team’s styling and theming efforts in sprint 3:

Conclusion

After three sprints, our team is well on its way to having a scalable component architecture in place for the UI.

• We are moving quickly thanks to react-bootstrap, but are no longer piling up loads of technical debt as a result of it.
• Thanks to styled-components, we were able to implement multiple themes (like how almost every app on the Internet these days sports dark and light modes). We also don’t look like an out-of-the-box Bootstrap app anymore.
• By implementing a custom component kit that contains all references to react-bootstrap, we can refactor away from it as time permits.

The post Iterating a React Design with Styled Components appeared first on CSS-Tricks.

I’ve heard people say that the #1 most exciting and important thing that came out of Google I/O this year was the evergreen Googlebot:

Today, we are happy to announce that Googlebot now runs the latest Chromium rendering engine (74 at the time of this post) when rendering pages for Search. Moving forward, Googlebot will regularly update its rendering engine to ensure support for latest web platform features.

Before this, I guess I never even thought about it.

I guess part of it is that some people did already know that the old version didn’t support some newfangled JavaScript stuff, and thus literally packaged their app with old JavaScript to be more SEO-friendly.

A bunch of people were apparently shipping older code simply for the sake of Googlebot, and now they don’t have to. Sure, I’ll call that a win.

Don’t read this news as “don’t worry about your JavaScript-rendered pages and SEO” though, because Google Webmasters is still telling us that pages with content that requires JavaScript to render are put into a special slower queue for both initial crawling and for updates. Not necessarily a penalty, but certainly a delay. I’m sure that’s enough to make server-side rendering a priority for sites where SEO is the whole ballgame.

Direct Link to Article — Permalink

The post Evergreen Googlebot appeared first on CSS-Tricks.

(This is a sponsored post.)

[Geoff:] I’ve built a fair number of WordPress sites in my day. It’s been my go-to since the 2.x-ish days because it works for any site, big or small. That’s the sort of solution and flexibility you like to have as a freelancer.

Boy, I wish I had Jetpack available in those early days.

Like WordPress itself, Jetpack is a good solution for many, many of the types of things clients are looking for from a WordPress site. I used to spend hours researching the right plugin for a specific feature, whether that was for comment filtering, asset caching, beefier search functionality, creating custom post types on the fly… you name it. All of that — and a heckuva lot more — is included in Jetpack right out of the box.

Here’s what I’m talking about. A friend of mine runs a pop-up gallery here locally. She displays paintings, photographs, sculptures… basically anything super artsy from super talented locals. That includes events, socials, performances and screenings. The wild thing is that it “pops” up in different spots, based on what she’s showing and what public space is available. So, you get how a website would be helpful for visitors to keep tabs on what’s coming up and where things are going to take place, not to mention getting a recap on past events.

We’ve all made sites for friends, right? It’s the kind of thing you do for free on the side. That makes it something you want to do well, but not necessarily spend a ton of time making. That’s where Jetpack really helped me out in this case.

If Jetpack is new to you, it’s a WordPress plugin that, as part of what it does, is bring features from WordPress.com and makes them available on your self-hosted WordPress sites.

For example, my friend really needed to showcase work. This is less of a content site and more of a visual experience, so media plays a big role. Photos, video, audio. You get it. Good thing Jetpack has a “Portfolio” custom post type at the ready.

That’s a perfect start for showing things off, but my friend also needed a carousel to allow visitors to browse photos from events and artist works. This would’ve been something I probably would have turned to the WordPress plugin directory for in the past, or perhaps some (back then) jQuery plugin, but thankfully Jetpack had my back there, too.

While we’re on the topic of media, we know that heavy image files are a recipe for slow sites. There’s a ton of WordPress plugins that can help with caching, gzipping, and even lazy loading, but all that’s already in Jetpack. Why go reinvent the wheel, especially on what’s supposed to be a pretty quick build?

I think you catch my drift. The fact is that Jetpack is an effective way to supercharge a self-hosted WordPress site, connecting it to many of the same powerful services that you’d otherwise need to go to WordPress.com — or gobs of third-party plugins — to get. Plus, it’s built by Automattic, so you know it integrates seamlessly with WordPress. No better confidence than going with something the primary maintainers of WordPress are willing to slap their name on!

Sure, we’ve only looked at a very simple example of how powerful Jetpack is for a small site. But don’t be fooled: Jetpack is capable of handling the needs of large-scale sites as well. In fact, we love Jetpack here at CSS-Tricks because it powers so much of what you see on the site, from social sign-in and automated sharing, to downtime monitoring and site search. It’s robust, dependable, and just gosh darn delightful to use.

And, hey, there’s a free tier you can start using right away and it includes a generous number of features that help with security, performance, analytics, and theming… and it only goes up from there. ?

Get Jetpack

Direct Link to Article — Permalink

The post Using Jetpack to Accelerate WordPress Development appeared first on CSS-Tricks.

const config = {
  fields: {
    username: {
      isRequired: { message: 'Please fill out a username' },
    },
    password: {
      isRequired: { message: 'Please fill out a password' },
      isMinLength: { value: 6, message: 'Please make it more secure' }
    }
  },
  onSubmit: e => { /* handle submit */ }
};
const { getFieldProps, getFormProps, errors } = useValidation(config);

{
  fields: {
    fieldName: {
      oneValidator: { validatorRule: 'validator value' },
      anotherValidator: { errorMessage: 'something is not as it should' }
    }
  }
}

const config = { ... }; // like above
const LoginForm = props => {
  const { getFieldProps, getFormProps, errors } = useValidation(config);
  return (
    <form {...getFormProps()}>
      <label>
        Username<br/>
        <input {...getFieldProps('username')} />
        {errors.username && <div className="error">{errors.username}</div>}
      </label>
      <label>
        Password<br/>
        <input {...getFieldProps('password')} />
        {errors.password && <div className="error">{errors.password}</div>}
      </label>
      <button type="submit">Submit my form</button>
    </form>
  );
};

const initialState = {
  values: {},
  errors: {},
  submitted: false,
};

function validationReducer(state, action) {
  switch(action.type) {
    case 'change': 
      const values = { ...state.values, ...action.payload };
      return { 
        ...state, 
        values,
      };
    case 'submit': 
      return { ...state, submitted: true };
    default: 
      throw new Error('Unknown action type');
  }
}

function validationReducer(state, action) {
  // Like above
}

const initialState = { /* like above */ };

const useValidation = config => {
  const [state, dispatch] = useReducer(validationReducer, initialState);
  
  return {
    errors: state.errors,
    getFormProps: e => {},
    getFieldProps: fieldName => ({
      onChange: e => {
        if (!config.fields[fieldName]) {
          return;
        }
        dispatch({ 
          type: 'change', 
          payload: { [fieldName]: e.target.value } 
        });
      },
      name: fieldName,
      value: state.values[fieldName],
    }),
  };
};

function isRequired(config) {
  return function(value) {
    if (value === '') {
      return config.message;
    } else {
      return null;
    }
  };
}

// or the same, but terser

const isRequired = config => value => 
    value === '' ? config.message : null;

{ 
  fields: {
    username: {
      isRequired: { message: 'Please fill out a username' },
    },
    password: {
      isRequired: { message: 'Please fill out a password' },
      isMinLength: { value: 6, message: 'Please make it more secure' }
    }
  },
  // more stuff
}

import * as validators from 'calidators';

function validateField(fieldValue = '', fieldConfig) {
  for (let validatorName in fieldConfig) {
    const validatorConfig = fieldConfig[validatorName];
    const validator = validators[validatorName];
    const configuredValidator = validator(validatorConfig);
    const errorMessage = configuredValidator(fieldValue);

    if (errorMessage) {
      return errorMessage;
    }
  }
  return null;
}

function validateField(fieldValue = '', fieldConfig) {
  // as before
}

function validateFields(fieldValues, fieldConfigs) {
  const errors = {};
  for (let fieldName in fieldConfigs) {
    const fieldConfig = fieldConfigs[fieldName];
    const fieldValue = fieldValues[fieldName];

    errors[fieldName] = validateField(fieldValue, fieldConfig);
  }
  return errors;
}

function validationReducer(state, action) {
  switch (action.type) {
    case 'change':
      // as before
    case 'submit':
      // as before
    case 'validate': 
      return { ...state, errors: action.payload };
    default:
      throw new Error('Unknown action type');
  }
}

const useValidation = config => {
  const [state, dispatch] = useReducer(validationReducer, initialState);

  useEffect(() => {
    const errors = validateFields(state.fields, config.fields);
    dispatch({ type: 'validate', payload: errors });
  }, [state.fields, config.fields]);
  
  return {
    // as before
  };
};

import useDeepCompareEffect from 'use-deep-compare-effect';

const useValidation = config => {
  const [state, dispatch] = useReducer(validationReducer, initialState);

  useDeepCompareEffect(() => {
    const errors = validateFields(state.fields, config.fields);
    dispatch({ type: 'validate', payload: errors });
  }, [state.fields, config.fields]);
  
  return {
    // as before
  };
};

const useValidation = config => {
  const [state, dispatch] = useReducer(validationReducer, initialState);
  // as before
  return {
    getFormProps: () => ({
      onSubmit: e => {
        e.preventDefault();
        dispatch({ type: 'submit' });
        if (config.onSubmit) {
          config.onSubmit(state);
        }
      },
    }),
    // as before
  };
};