Archive for month: November, 2020

Original Source: https://smashingmagazine.com/2020/11/reactive-variables-graphql-apollo-client/

In this article, we will look at how to set up reactive variables, how the GraphQL cache polices come into place in defining read and writes to the cache, and provide the ability for developers to add types that exist on the client-side alone so that we can structure queries for client-side variables same way we can for remote GraphQL data. After learning more about the fundamentals of reactive variables, we will build a simple app that switches the theme of our application to either dark mode or light mode based on the value of our reactive variable. We will be looking at how to query a reactive variable, how to update the value stored in a reactive variable, and how the change in value triggers updates in components that depend on the reactive variable for certain actions to occur.

The target audience for this article would include software developers who already use GraphqQL with state management tools like Context API or Redux and willing to explore a new pattern of handling state management in GraphQL, or GraphQL beginners who are looking for effective ways to handle globally shared local state within GraphQL without Making things too complicated with external tooling. To follow along with this, you should have an existing knowledge of ReactJS and CSS too.

A Quick Introduction To GraphQL

With GraphQL, you get exactly what you need, and also get the data returned as well as structured how you need it.

“GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.”

— GraphQL website

What Is Apollo Client In GraphQL?

Apollo Client helps you avoid manually tracking loading and error states. It also provides the ability to use GraphQL with modern React patterns like hooks, and so on.

“Apollo Client is a comprehensive state management library for JavaScript that enables you to manage both local and remote data with GraphQL. Use it to fetch, cache, and modify application data, all while automatically updating your UI.”

— “Introduction to Apollo Client,” Apollo Docs

Let’s define some terms here that you will need to understand to move forward:

Variable
A variable is a name you give to an assigned memory location where a value is stored. The variable name is used as a reference to the value stored in it when you need to make use of it.
Reactivity
We will explain reactivity as something that triggers change on its dependents when an update is passed to it. Like the local state in React triggers component updates, the reactive variables in Apollo GraphQL also automatically trigger component updates based on changes.

State management is a really important part of building a modern application. Having a global state is important when different components or screens require access to the same state value and possibly trigger changes when that particular state is changed.

In the next section, we will look at how to set up a reactive variable.

Writing Our First Reactive Variable

Here’s what a reactive variable looks like:

import { makeVar } from ‘@apollo/client’;

const myReactiveVariable = makeVar(/** An initial value can be passed in here.**/)

The makeVar is imported from Apollo Client and is used to declare our a reactive variable. The makeVar takes an initial value that the reactive variable would hold. The ease of constructing a reactive variable is amazing.

There are two ways to read data from our created reactive variable. The easiest way is to call our declared reactive variable which we have created above, as a function without an argument:

const variable = myReactiveVariable();

Getting the value of a reactive variable is that easy. In the code block above, we declared a variable that holds our reactive variable which was called without an argument to read the data it already holds.

We can also get the value of a reactive variable with the useQuery syntax we normally would use to fetch remote data in GraphQL. To explain how we can do this, let’s look at the Cache type and field policies.

Type And Field Policies

The cache type and field policies help you define how a specific field in your Apollo Client cache is read and written to. You do this by providing field policies to the constructor of inMemoryCache. Each field policy is defined inside the typePolicy that corresponds to the type which contains the field. Let’s define a typePolicy called Query and define a field policy for accessing a field called myReactiveVariable.

import { InMemoryCache } from ‘@apollo/client’;

// Here we import our reactive variable which we declared in another
// component
import { myReactiveVariable } from ‘./reactivities/variable.js’;

// The field policies hold the initial cached state of a field.
export default new InMemoryCache({
typePolicies: {
Query: {
fields: {
myReactiveVariable: {
read() {
return myReactiveVariable();
}
}
}
}
}
})

In the code snippet above, we declared a type called Query and defined a field called myReactiveVariable. Next, we added a read function that specifies what happens when the field’s cached value is read. Here’s what happens when the myReactiveVariable field cached value is being read:

We pass in the reactive variable we had declared in another component and imported here as the value the field returns.

Now that we have defined our typePolicies and fieldPolicies, let us go ahead and write our query to get the value store in our reactive variable. Here’s what the query would look like:

import { gql } from “@apollo/client”;

export const GET_REACTIVE_VARIABLE = gql`
query getReractiveVariable{
myReactiveVariable @client
}
`

The gql template literal tag we imported from Apollo Client above is used to write a GraphQL query in Apollo client.

The query name myReactiveVariable should match the field name declared in the field policy. If you have been using GraphQL, you will notice that this querying pattern is identical to the normal query you would write if it were to be a remote GraphQL API we were querying. The only difference is the @client placed after the field name. This instructs Apollo to resolve this particular query on the client and not on any external API.

That’s it! We have successfully set up our first reactive variable. The process looks a little bit lengthy initially but subsequently, you can declare a new reactive variable by simply declaring the reactive variable and adding a field policy for it.

To fetch the reactive variable, you can use the useQuery hook in any component where you need it.
Here’s an example.

import { useQuery } from ‘@apollo/client’;
import { GET_REACTIVE_VARIABLE } from ‘FILE_PATH_TO_YOUR_QUERY_FILE’;

const {loading, error, data} = useQeury(GET_DARK_MODE);

// you can track loading, error states, and data the same way with a normal query in Apollo

In the above code, we imported useQuery from @apollo/client. Next, we imported the GET_REACTIVE_VARIABLE query from the file it was exported from.

Lastly, we pass on to the useQuery hook in our query, and destructure loading, error, and data from it.

Modifying A reactive variable

Apollo client provides a beautiful way to modify a reactive variable — calling the function returned by makeVar and pass in a single argument to the function. The argument passed in is the new value the reactive variable will hold. Let us look at an example below where we modify our reactive variable which we declared above:

import { myReactiveVariable } from ‘PATH_TO_OUR_REACTIVE_VARIABLE_FILE’

myReactiveVariable(“A new value is in!”);

In the above code, we import myReactiveVariable and we update it by calling the variable and placing the new value inside of it.

It is so easy to update the values of a reactive variable. Once the value in a reactive variable is updated, corresponding actions are triggered in components that depend on the variable and the user-interface is adjusted automatically.

In the next section, we will build out a simple theme-changing application that switches themes from dark mode to light mode with a click of a button. The button changes itself based on the value of the current theme. This will help us put all that we have learned together by building out something that fully and simply illustrates the concept of reactive variables and show how the user interface is automatically triggered when the reactive variable is updated.

Here’s what our result will look like:

(Large preview)

Let’s begin.

Setup

First, we create a new React app.

npx create-react-app theme_toggle

Next, let’s install the necessary libraries we need for Apollo and GraphQL including the react-feather library to get our icons and react-router-dom to setup routing

npm install @apollo/client graphql react-feather react-router-dom

Once we are done with all the installations, let’s go ahead and set up our graphQL, including defining our darkMode reactive variable.

Create a folder called graphql inside the src folder and then create a sub-folder called reactivities to house all the reactive variables. Here’s how the folder tree would look like:
src > graphql > reactivities > themeVariable.js

I decided to arrange our file and folder structure simulating a real-world use case so follow along.
Let’s go ahead to declare our reactive variable in the themeVariable.js file we just created:

import { makeVar, gql } from “@apollo/client”;
export const darkMode = makeVar(false);

Next, inside the same file let’s construct our query to get our reactive variable and specify that the query should be resolved on the client-side. We can decide to create a separate folder to house all our query, especially when we have many queries in our application, but for the sake of this tutorial, we will write the query inside the same file as the reactive variable and export them individually:

import { makeVar, gql } from “@apollo/client”;

export const darkMode = makeVar(false);

// This is the query to get the darkMode reactive variable.
export const GET_DARK_MODE = gql`
query getDarkMode{
darkMode @client
}
`

In the above piece of code, we see how straightforward it was to declare a reactive variable with the makeVar() and passed in an initial value of false for our new variable. Next, we imported gql from Apollo client and used it in writing our query.

Next, let’s create our cache.js file and define our type and field policies to control how variables will be queried and structured:

Create a file called cache.js inside the graphql folder. Inside cache.js here’s how we declare our policies:

import { InMemoryCache } from ‘@apollo/client’;
import { darkMode } from ‘./reactivities/themeVariable’;

export default new InMemoryCache({
typePolicies: {
Query: {
fields: {
darkMode: {
read() {
return darkMode();
}
}
}
}
}
})

In the above code, first, we imported inMemoryCache from Apollo client, and we imported our reactive variable from the file path where we stored it.
Next, we created a new instance of inMemoryCache and our field policy is defined inside of the typePolicy object. The code above defines a field policy for the darkMode field on the Query type.

There’s one final step to complete our setup for Apollo for our React app, we need to create a client.js file. The client.js file is a file you’re already familiar with if you use GraphQL before now. It holds the ApolloClient constructor which would finally get passed into the ApolloProvider on a top-level file (usually the index.js file). Our client.js file should be located directly inside the src folder.

src > client.js

import { ApolloClient } from ‘@apollo/client’;
import cache from ‘./graphql/cache’;
const client = new ApolloClient({
cache,
connectToDevTools: true,
});
export default client;

Here’s what we did above. We imported ApolloClient. Next, we imported our cache from where it was previously declared. Inside our ApolloClient constructor, we passed in our cache which we imported and set connectToDevTools as true to enable us to use the Apollo Dev Tools in our browser.

Finally, we need to pass in the new ApolloClient instance which we exported as client into ApolloProvider in our top-level index.js file inside the src folder. Open the index.js file and replace the code there with this.

import React from ‘react’;
import ReactDOM from ‘react-dom’;
import { ApolloProvider } from ‘@apollo/client’;
import ‘./index.css’;
import App from ‘./App’;
import client from ‘./client’;
ReactDOM.render(
<ApolloProvider client={client}>
<App />
</ApolloProvider>,
document.getElementById(‘root’)
);

In the above code block, we wrapped our App component with the ApolloProvider and passed client (which we imported) to the Apollo provider. We did this in the top-level scope so that our entire app can access the ApolloProvider and the client.

We have successfully finished everything in the setup of Apollo and the reactive variable. You’ll notice that many things we did here were related to setting up Apollo which you would still have done even if you were using Apollo with other external API for managing context.

Since we are done with everything we need to set up Apollo and create our reactive variable, let’s now go ahead and set up our page and routing.

We would only have one route to a page called landingPage.jsx. Inside the src folder, create a folder called pages to house all the pages (in our case, we have just one page) and create a file called landingPage.jsx in it.

src > pages > landingPage.jsx

Inside our newly created page, let’s create a functional component with a h1 tag containing or heading. Here’s what will be in it.

import React from ‘react’;

const LandingPage = () => {
return (
<div
style={{
height: ‘100vh’,
backgroundColor: ‘white’,
}}
>
<h1>Welcome to Theme Toggle Appliation!</h1>
</div>
)
}
export default LandingPage

Next, let’s create our button component. Inside src, create a folder called components, and create a button.jsx file.
src > components > button.jsx

Inside our button component, here are the things we should import icons from react-feather, the useQuery hook from apollo/client, our query and reactive variable from the file it was exported from.

import React from ‘react’
import { Moon, Sun } from ‘react-feather’;
import { useQuery } from ‘@apollo/client’;
import { GET_DARK_MODE, darkMode as reactiveDarkMode } from ‘../graphql/reactivities/themeVariable’;

Inside the button component, let’s query our GraphQL client with the GET_DARK_MODE query like how we would normally query in GraphQL with Apollo.

…

const ButtonComponent = () => {

{loading, error, data} = useQuery(GET_DARK_MODE);

return (…)
}

export default ButtonComponent;

Next, we want to change the buttons based on the boolean value of our reactive variable that will be returned from data. To do this, we will create two buttons and use a ternary operator to display them conditionally based on the boolean value of our reactive variable:

…

const ButtonComponent = () => {

const {loading, error, data} = useQuery(GET_DARK_MODE);

return (
<div>
{
data.darkMode ? (
<button
style={{
backgroundColor: ‘#00008B’,
border: ‘none’,
padding: ‘2%’,
height: ‘120px’,
borderRadius: ’15px’,
color: ‘white’,
fontSize: ’18px’,
marginTop: ‘5%’,
cursor: ‘pointer’
}}
onClick={toggleMode}
>
<Sun />
<p>Switch To Light Mood</p>
</button>
) 🙁
<button
style={{
backgroundColor: ‘#00008B’,
border: ‘none’,
padding: ‘2%’,
height: ‘120px’,
borderRadius: ’15px’,
color: ‘white’,
fontSize: ’18px’,
marginTop: ‘5%’,
cursor: ‘pointer’
}}
onClick={toggleMode}
>
<Moon />
<p>Switch To Dark Mood</p>
</button>
)
}
</div>
)
}
export default ButtonComponent;

In the above code, we displayed both buttons conditionally with the ternary operator to display when the value of data.darkMode is either true or false. Our initial value as declared in our themeVariable.js is false.

Note: Remember that we can pull out darkMode from the data because we declared it this way in our cache.js field policy.

We added some CSS to the buttons to make them look better and also added the icons we imported from react-feather to each button.

If you noticed we had an onClick property passed into each button which called toggleMode. Let’s declare the function above but still inside the ButtonComponent:

…

const ButtonComponent = () => {

const toggleMode = () => {
console.log(“Clicked toggle mode!”)
}

return (…)
}

export default ButtonComponent;

Currently, we have a console.log() inside the toggleMode function. In a later part of this article, we will come back to properly write this function to update the value of the reactive variable.

Now let’s go back to the ladingPage.jsx file we created before now and add the button we just created:

import React from ‘react’;
import ButtonComponent from ‘../components/button’;

const LandingPage = () => {
return (
<div
style={{
height: ‘100vh’,
backgroundColor: ‘white’,
}}
>
<h1>Welcome to Theme Toggle Appliation!</h1>
<ButtonComponent />
</div>
)
}
export default LandingPage

To add the button, we simply imported it into our page and added it below the h1 element we already had on the page.

Here’s how our web app looks like at the moment.

We are almost done building our app. Next, let’s change the background and text color of the page in the landingPage.jsx style to conditionally be black or white based on the boolean value of our reactive variable which would be toggled in the button component later. To do this, we will also use the useQuery hook to get the current value of our reactive variable.

Our landingPage.jsx file will finally look like this:

import React from ‘react’
import { useQuery } from ‘@apollo/client’;
import ButtonComponent from ‘../components/button’;
import { darkMode, GET_DARK_MODE } from ‘../graphql/reactivities/themeVariable’;

const LandingPage = () => {
const {loading, error, data} = useQuery(GET_DARK_MODE);
return (
<div style={{ height: ‘100vh’, backgroundColor: data.darkMode ? ‘black’ : ‘white’, color: data.darkMode ? ‘white’ : ‘black’ }}>
<h1>Welcome to Theme Toggle Appliation!</h1>
<ButtonComponent />
</div>
)
}
export default LandingPage

Pay attention to the way we change the backgroundColor and color of the div container conditionally based on the boolean value of the reactive variable returned. We make use of a ternary operator to set the backgroundColor to black or white depending on the value of data.darkMode. The same thing should be done for the value of color. This is all we need to for the landingPage.jsx component.

The final thing we will need to do to get our application to be working is to make our toggleMode function in the button component able to modify the reactive variable on click of the button. Let’s look at how to modify a reactive variable again, this time, in a real app example.

Modifying A Reactive Variable

As we’ve previously learned, to modify a reactive variable, all you need to do is to call the function returned by makeVar and pass in the new value inside of it. Here’s how that will work in our case:

Go to the button component and do this:

…
import { GET_DARK_MODE, darkMode } from ‘../graphql/reactivities/themeVariable’;

const ButtonComponent = () => {

const toggleMode = () => {
darkMode(!darkMode)
}

return (…)
}

export default ButtonComponent;

First, we imported the GET_DARK_MODE query and the darkMode reactive variable from the file they were exported from.

Next, we wrote an arrow function for toggleMode and called the darkMode function returned by makeVar and passed an invert of the current value it contained as the new value the reactive variable will carry when it is clicked on.

We have our entire app powered by a reactive variable and once there’s a change to the value held in the reactive variable, every component or page dependent on that variable for an action to trigger is updated and the user interface is updated with the current changes. We escaped all the hurdles of dispatch functions and other ambiguous steps we have to follow when using other state management libraries like Redux or Context API.

Conclusion

Reactive variables in Apollo client give you a sweet, easy to use, easy to update, and a consistent querying pattern with querying a regular remote GraphQL API. Learning to use reactive variables for state management is a plus to you because it gives you the flexibility of choice among many tools. reactive variables would enable you to manage locally shared global state among components without the extra boilerplate that would usually come with the dominant state management libraries that already exist.

Check out the finished code on GitHub.

Related Resources

Reactive Variables, Apollo Docs
Local State Management With Reactive Variables
Configuring The Cache, Apollo Docs

Original Source: http://feedproxy.google.com/~r/tympanus/~3/zruv5SJkqPQ/

Inspirational Website of the Week: Loftgarten

Design excellence in every way: layout, typography, colors and interactions are just spot-on!

Get inspired

Our Sponsor
The Divi Black Friday Sale

Black Friday is the only time each year that we offer 25% off new Divi memberships and Divi membership upgrades and along with each purchase, customers also get access to a free prize. We are giving away premium Divi modules, child themes and layouts in batches.

Get ready!

Playfulness In Code: Supercharge Your Learning By Having Fun

The master of dev fun, Jhey Tompkins, shows how having fun can supercharge your learning in this great article.

Read it

Swimming on Scroll with GSAP

Alex Trost dissects the amazing “Weird Fishes” demo by Michelle Barker.

Read it

What are design tokens?

Learn why design tokens are a powerful way of sharing design properties and how they work.

Read it

Color Theming with CSS Custom Properties and Tailwind

Michelle Barker explains how custom properties can be used for theming, and how they can be integrated with Tailwind to maximize the reusability of our code.

Read it

Tomorrowland: Digital Event

Dogstudio’s great case study of how they built a new kind of immersive experience for Belgium’s EDM sweetheart.

Read it

Web Development for Beginners – A Curriculum

Azure Cloud Advocates at Microsoft are pleased to offer a 12-week, 24-lesson curriculum all about JavaScript, CSS, and HTML basics.

Read it

Text Gradients in CSS

A great tip on how to create text gradients in CSS using the background-clip property.

Read it

The case for Weak Dependencies in JS

Lea Verou has some interesting thoughts in “weak dependecies” in JavaScript.

Read it

Liquid masking – scroll

A great demo by Cassie Evans that shows a cool liquid masking scroll effect.

Check it out

Thinking Like a Front-end Developer

Learn how to think as a front-end developer and account for edge cases you might have missed.

Read it

MIDWAM

A really cool immersive web experience.

Check it out

Disable mouse acceleration to provide a better FPS gaming experience

Learn about how web apps can now disable mouse acceleration when capturing pointer events.

Read it

Draggable elastic

A great starting template for a cool slider by Jesper Landberg.

Check it out

CSS clip-path Editor

A very useful clip-path editor made by Mads Stoumann.

Check it out

The most accurate way to schedule a function in a web browser

A detailed analysis of 3 JavaScript timeout strategies (setTimeout, requestAnimationFrame & Web Worker) and how they perform in thousands of web contexts. By Benoit Ruiz.

Read it

Shifting an image with canvas

Christian Heilmann shows how to use HTML canvas to shift the pixels of an image.

Read it

Flash Animations Live Forever at the Internet Archive

Great news for everyone concerned about the Flash end of life planned for end of 2020: The Internet Archive is now emulating Flash animations, games and toys in our software collection.

Read it

Building a Web App Powered by Google Forms and Sheets

Learn how to use Google Forms and Sheets to build a client-side application.

Read it

A centered CSS navigation with fit-content

Stefan Judis shows a CSS pattern that uses ‘fit-content’ to center a flexible-width navigation.

Read it

Modern HTML Starter Template

Igor Agapov created this starter template for HTML projects that comes with some useful contents.

Check it out

From Our Blog
Inspirational Websites Roundup #20

Our favorite website designs that we’ve collected over the past couple of weeks for your inspiration.

Check it out

From Our Blog
Image Stack Intro Animation

Two simple intro animations where an image stack moves to become a grid using GSAP and Locomotive Scroll.

Check it out

From Our Blog
Replicating the Icosahedron from Rogier de Boevé’s Website

Learn how to replicate the beautiful icosahedron animation from Rogier de Boevé’s website using Three.js and GLSL.

Check it out

The post Collective #636 appeared first on Codrops.

Original Source: https://www.webdesignerdepot.com/2020/11/8-awesome-black-friday-2020-deals-for-designers-up-to-94-off/

If you’re interested in a sneak peek of this year’s best Black Friday deals, stick around. You’ll find a few web designers’ favorites, including a stellar deal or two.

This year, more than a few of the popular retail outlets are shifting away from the traditional “camp out all night and bust open the doors when the store opens” shopping model. You might just prefer this less chaotic, ecommerce approach.

All of us are trying to adjust to what may eventually become a “new normal”. We may not like some aspects of this new normal, but there are bright spots as well.

More shoppers are likely going to shop online because of the coronavirus. That means you don’t have to fight the crowds while desperately attempting to socially distance. The shelves aren’t as apt to go bare, and shopping is easy, convenient, and safe.

1. Slider Revolution

You will find the Slider Revolution plugin incorporated in a host of WordPress theme tools and products. This premium plugin can in fact boast of more than 7 million users around the globe.

What you may not be aware of is that it is much more than just a WordPress slider. With it in your web design toolbox, you can in fact create just about anything you can imagine.

Expect to find:

A stunning selection of elements including sliders and carousels;
Attention-getting hero sections designed to make your home pages really stand out;
Single-page websites with layouts unlike anything you’ve seen before;
Modular structuring that allows you to rearrange and reuse sections however you choose and the ability to mix and match modules with any WordPress content;
Add-ons whose cutting edge features push the boundaries of web design possibilities.

There’s more of course. To celebrate Black Friday and Cyber Monday you can NOW get any Slider Revolution subscription plan or one-time payment at a 33% discount.

Just click on the banner and use the BLACKFRIDAY code at checkout.

2. Amelia

When done manually, booking and managing appointments can be tedious and subject to mistakes and errors. Amelia provides an automated booking process that is oh-so easy to work with and is error free; just what you need to help you acquire more happy customers.

Key features of Amelia’s fully responsive design include:

A dashboard system that enables you to track approved and pending appointments, booking changes, and revenue;
Zoom Integration, Google Calendar, and Outlook Calendar sync;
The ability to accept and easily manage recurring appointments that customers can schedule;
Front-end customer and employee appointment and event managing and backend appointment adding, editing, and rescheduling;
Email notifications for pending and approved appointments and events.

And much more that will save you loads of energy and a ton of time. Give Amelia a try, and if you like what you see (and you will), take advantage of the 30% Black Friday discount.

3. wpDataTables

wpDataTables 3.0, with its fresh, new look, gives you a host of different ways to generate attractive, customizable, and responsive tables and charts, and a host of different ways to present them.

Tables can be created from most data sources, the most common being MySQL query, PHP array, Google Spreadsheet, Excel files CSV files, and JSON and XML inputs;
A working knowledge of SQL is not required!
Addons include Gravity Forms, Formidable Forms, Report Builder, and Powerful Filter;
wpDataTables users can generate Tables and Charts quickly from massive amounts of data (saving hours of effort);
Tables and charts are customizable and maintainable (editable once placed in use);
Tables can be created manually if you wish.

Click on the banner now and take advantage of wpDataTables 30% Black Friday discount on all licenses and addons.

4. TheGem – Creative Multi-Purpose High-Performance WordPress Theme

In TheGem, the ultimate WordPress multipurpose toolbox, you will find:

A rich selection of 400+ premium pre-built multi-page and one-page websites, all available for Elementor and WPBakery page builders;
The ability to mix and match any of this demos, layouts and page sections to create your own unique look;
Extended WooCommerce layouts & tools for making online shops, which convert better;
TheGem Blocks: an ultimate tool for building webpages at the speed of light.

And much more. Just click on the banner and check this 5-star product out.

5. Mobirise Website Builder

Creating a Google-friendly can take time, unless you have Mobirise at your fingertips, in which case you have a number of helpful tools to speed things up.

No coding, it’s all drag and drop;
3,600+ website templates are at your disposal plus sliders, popups, forms, and more;
Many eCommerce features, including a shopping cart;
Latest Google Amp and Bootstrap4;
You can download Mobirise for free.

And, because it’s Black Friday, everything is yours at a 94% discount!

6. Get Illustrations

Get Illustrations offers royalty free and landing page Illustrations ready to drag and drop into your web design. You’ll have access to:

An extensive library of 4000+ illustrations with more added every week;
A wealth of design formats, including AI, PNG, SVG, Figma, Adobe XD, and Sketch;
Free updates and new illustrations weekly (included in the bundle).

Click on the banner and use the Coupon Code BLACKDEAL for your 30% discount.

7. XStore | Responsive Multi-Purpose WooCommerce WordPress Theme

For anyone planning on creating an eCommerce store, the XStore name says it all. Key features you’ll find in this powerful and flexible WooCommerce theme include:

More than 95 good-to-go-shops plus a full AJAX shop to get you started;
300+ pre-defined shop/page sections, a header builder, and a single product page builder;
Elementor, WPBakery and $510+ worth of premium plugins.

Click on the banner and sign up to become one of XStore’s 55,000+ happy customers.

8. Kalium – Creative Theme For Multiple Uses

Kalium is an easy-to-use, easily maintainable multipurpose theme for WordPress users that is always updated to use the latest WordPress standards.

Kalium provides its users with a host of professionally-designed pre-built demos and elements;
Many plugins such as: Slider Revolution, WPBakery, Elementor, Layer Slider, Advanced Custom Fields PRO, Product Filter for WooCommerce, Product Size Guide,WooCommerce and other premium plugins are included.

Kalium is responsive, GDPR compliant, and gives you full eCommerce and top-quality customer support. It has a 5-star rating after 36k sales on ThemeForest – seriously impressive!

***** 

If you hit the retail stores remember to social distance.

Or, if you would rather take a brief break from the demands of Covid-19, take advantage of one or more of the above ecommerce sales. As you can see, there are some excellent ones!

 

[– This is a sponsored post –]

Source

p img {display:inline-block; margin-right:10px;}
.alignleft {float:left;}
p.showcase {clear:both;}
body#browserfriendly p, body#podcast p, div#emailbody p{margin:0;}

Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/JBEiYmTxNdI/mostra-de-arte-da-juventude-branding-and-visual-identity

Mostra de Arte da Juventude Branding and Visual Identity

abduzeedo11.24.20

In 2019, the MAJ (Youth Art Exhibition) celebrated its 30th anniversary and Sesc invited Polar to develop the project’s new logo, as well as the branding, visual identity, and signage of the commemorative edition. Following the format of traditional art salons, the exhibition sheds light on contemporary young art production. Currently, it is one of the main cultural events in the interior of the state of São Paulo and places the city of Ribeirão Preto on the Brazilian’s visual arts map.

The new MAJ logo was designed combining geometric shapes with ink traps that pushes it away from a typically modernist solution. The highlight is the character ‘M’, which gains an extra “leg” to reproduce the boost given to MAJ’s featured artists.

The 30-year edition’s visual identity simultaneously pays tribute to the new artists discovered and the city of Ribeirão Preto. We created a series of graphics that refer to sparks, representing young talents at the time of expansion and professional growth, as well as Ribeirão ‘s powerful sun.

Original Source: http://feedproxy.google.com/~r/tympanus/~3/Nddu7rzhAhA/

Inspirational Website of the Week: Grove Lust

Beautiful simplicity, unique colors and a fun interactive effect made us pick Grove Lust this week.

Get inspired

This content is sponsored via Syndicate Ads
The #1 Leader in Heatmaps, Recordings, Surveys & More

Hotjar shows you how visitors are really experiencing your website—without drowning in numbers. Sign up for a 15-day free trial.

Try it free

Back/forward cache

Learn how to optimize your pages for instant loads when using the browser’s back and forward buttons. By Philip Walton.

Read it

Pattern Collect

A curated gallery of patterns by awesome designers and illustrators

Check it out

Simple pie charts with fallback, today

Lea Verou shows a modern solution for pie charts with a fallback for older browsers.

Read it

A Deep Dive Into CSS Grid minmax()

Learn how CSS grid minmax() works, with a detailed visual explanation for auto-fit and auto-fill keywords.

Check it out

ThreeJS starter

A fantastic Three.js boilerplate made by Francesco Michelini. It uses Parcel to create the bundle and Tweakpane for live updates. Here’s the demo.

Check it out

Tailwind CSS v2.0

Read about the new Tailwind CSS version that includes an all-new color palette, dark mode support, and a lot more.

Read it

upptime

An uptime monitor and status page powered by GitHub.

Check it out

Masonry Layout

Level 3 of the CSS Grid Layout specification includes a masonry value for grid-template-columns and grid-template-rows. This MDN guide details what masonry layout is, and how to use it.

Read it

SvgPathEditor

A very useful online editor to create and manipulate SVG paths.

Check it out

Warp: Improved JS performance in Firefox 83

An article that explains how Warp works, a significant update to SpiderMonkey.

Read it

Standardizing <select> And Beyond: The Past, Present And Future Of Native HTML Form Controls

In this article, Stephanie Stimac dives into the past by going back to the beginning of HTML and tracing the evolution of form controls through to the present and the current state of working with them.

Read it

Railroad switches game

A simple remake of an 8 bit minigame in ~150 lines of pure JavaScript.

Check it out

Simulating color vision deficiencies in the Blink Renderer

This article describes why and how we implemented color vision deficiency simulation in DevTools and the Blink Renderer.

Read it

Draggable Blend Generator

A generator that lets you experiment with the background-blend-mode and mix-blend-mode CSS properties.

Check it out

GSAP Believe – Collage Animation

A very beautiful collage animation made by Shunya Koide.

Check it out

Interstellar

A tweakable demo made by Arnaud Di Nunzio.

Check it out

Inside the Mind of Samuel Day

What an awesome scroll experience!

Check it out

Building My First PC

Tania Rascia shares how she built her own PC in this great article.

Read it

Kode Sports Club

A really cool interactive 3D tour for a spots club. Made by the folks of Merci-Michel.

Check it out

PAC-MAN Password Reveal w/ GSAP

A fun password reveal effect made by Jhey.

Check it out

Romanizer

A great project made with Vue.js: a roman numerals converter.

Check it out

From Our Blog
UI Interactions & Animations Roundup #12

Some fresh UI interaction and animation concepts for your inspiration.

Check it out

From Our Blog
Coding the Golden Spiral City from the Creative Cruise Website with Pixi.js

Dive into a remake of Creative Cruise’s amazing golden spiral city using Pixi.js.

Check it out

The post Collective #635 appeared first on Codrops.