There’s a series questions I have struggled with for as long as I can remember. The questions have to do with how design systems work: Where should we document things? Do we make a separate app? Do we use a third-party tool to document our components? How should that tie into Figma or Sketch? What about written documentation? Should we invest a lot of time into making a giant Polaris-like wiki of how to build things?

The issue with all these tools and links and repositories is that it can become increasingly difficult to remember where to go for what kind of information. Designers should go here and engineers should go there — unless, of course, you’re an iOS engineer, then you need this special resource instead. It can be overwhelming and confusing for everyone that doesn’t live within the orbit of design systems drama and is just trying to ship a feature on time.

After years of struggling with these questions, I think my current advice to my past (and current) self is this: meet the people where they are. And where are most people asking questions about design systems, whether that’s a color variable or a component or a design pattern?

In Slack!

The other day I thought it would be neat to set up some Slackbot custom responses to do a rather simple thing. When someone types color me into a channel, I all the color variables and their hex values are pasted. That way, no one needs to learn a new tool or bookmark yet another link.

Here’s how it works.

We first have to open up the settings of the organization you’re in and click the “Customize” item in this dropdown:

That pops open a new tab with the “Customize your Workspace” settings. If you select “Slackbot” from the options, then you can then see all of the custom responses that have been set up already. From there, we can create a new response like this:

That n is what breaks things onto a new line so that I can now test it out in a chat with myself once I’ve saved this:

Because this takes up so much darn space, I also made separate answers for each color, like blue and purple. But all of this has me wondering: how else can we use Slack — or whatever chat app or communication tool — to extend the cause of good design systems work?

I bet there’s a ton of other things we can do to improve our lives within tools like this and make design systems work even easier.

The post The Best Design System Tool is Slack appeared first on CSS-Tricks.

Only Firefox supports it, but if you return a request with a header like this:

Header add Link "<style.css>;rel=stylesheet;media=all"

…that will link to that stylesheet without you having to do it in the HTML. Louis Lazaris digs into it:

[…] the only thing I can think of that could justify use for this in production is as a way to include some Firefox-only CSS, which Eric Meyer mentions as a possibility in an old post on this subject. But it’s not guaranteed to always only work in Firefox, so that’s still a problem.

Do with this what you like, but it’s extremely unlikely that this will have any use in a real project.

I appreciate some classic CSS trickery.

Direct Link to Article — Permalink

The post Adding CSS to a Page via HTTP Headers appeared first on CSS-Tricks.

Webmention is a W3C recommendation last published on January 12, 2017. And what exactly is a Webmention? It’s described as…

[…] a simple way to notify any URL when you mention it on your site. From the receiver’s perspective, it’s a way to request notifications when other sites mention it.

In a nutshell, it’s a way of letting a website know it has been mentioned somewhere, by someone, in some way. The Webmention spec also describes it as a way for a website to let others know it cited them. What that basically bails down to is that your website is an active social media channel, channeling communication from other channels (e.g. Twitter, Instagram, Mastodon, Facebook, etc.).

How does a site implement Webmentions? In some cases, like WordPress, it’s as trivial as installing a couple of plugins. Other cases may not be quite so simple, but it’s still pretty straightforward. In fact, let’s do that now!

Here’s our plan

1. Declare an endpoint to receive Webmentions
2. Process social media interactions to Webmentions
3. Get those mentions into a website/app
4. Set the outbound Webmentions

Luckily for us, there are services in place that make things extremely simple. Well, except that third point, but hey, it’s not so bad and I’ll walk through how I did it on my own atila.io site.

My site is a server-side blog that’s pre-rendered and written with NextJS. I have opted to make Webmention requests client-side; therefore, it will work easily in any other React app and with very little refactoring in any other JavaScript application.

Step 1: Declare an endpoint to receive Webmentions

In order to have an endpoint we can use to accept Webmentions, we need to either write the script and add to our own server, or use a service such as Webmention.io (which is what I did).

Webmention.io is free and you only need to confirm ownership over the domain you register. Verification can happen a number of ways. I did it by adding a rel="me" attribute to a link in my website to my social media profiles. It only takes one such link, but I went ahead and did it for all of my accounts.

<a
  href="https://twitter.com/atilafassina"
  target="_blank"
  rel="me noopener noreferrer"
>
  @AtilaFassina
</a>

Verifying this way, we also need to make sure there’s a link pointing back to our website in that Twitter profile. Once we’ve done that, we can head back to Webmention.io and add the URL.

This gives us an endpoint for accepting Webmentions! All we need to do now is wire it up as tags in the of our webpages in order to collect those mentions.

<head>
  <link rel="webmention" href="https://webmention.io/{user}/webmention" />
  <link rel="pingback" href="https://webmention.io/{user}/xmlrpc" />
  <!-- ... -->
</head>

Remember to replace {user} with your Webmention.io username.

Step 2: Process social media interactions into Webmentions

We are ready for the Webmentions to start flowing! But wait, we have a slight problem: nobody actually uses them. I mean, I do, you do, Max Böck does, Swyx does, and… that’s about it. So, now we need to start converting all those juicy social media interactions into Webmentions.

And guess what? There’s an awesome free service for it. Fair warning though: you’d better start loving the IndieWeb because we’re about to get all up in it.

Bridgy connects all our syndicated content and converts them into proper Webmentions so we can consume it. With a SSO, we can get each of our profiles lined up, one by one.

Step 3: Get those mentions into a website/app

Now it’s our turn to do some heavy lifting. Sure, third-party services can handle all our data, but it’s still up to us to use it and display it.

We’re going to break this up into a few stages. First, we’ll get the number of Webmentions. From there, we’ll fetch the mentions themselves. Then we’ll hook that data up to NextJS (but you don’t have to), and display it.

Get the number of mentions

type TMentionsCountResponse = {
  count: number
  type: {
    like: number
    mention: number
    reply: number
    repost: number
  }
}

That is an example of an object we get back from the Webmention.io endpoint. I formatted the response a bit to better suit our needs. I’ll walk through how I did that in just a bit, but here’s the object we will get:

type TMentionsCount = {
  mentions: number
  likes: number
  total: number
}

The endpoint is located at:

https://webmention.io/api/count.json?target=${post_url}

The request will not fail without it, but the data won’t come either. Both Max Böck and Swyx combine likes with reposts and mentions with replies. In Twitter, they are analogous.

const getMentionsCount = async (postURL: string): TMentionsCount => {
  const resp = await fetch(
    `https://webmention.io/api/count.json?target=${postURL}/`
  )
  const { type, count } = await resp.json()


  return {
    likes: type.like + type.repost,
    mentions: type.mention + type.reply,
    total: count,
  }
}

Get the actual mentions

Before getting to the response, please note that the response is paginated, where the endpoint accepts three parameters in the query:

• page: the page being requested
• per-page: the number of mentions to display on the page
• target: the URL where Webmentions are being fetched

Once we hit https://webmention.io/api/mentions and pass the these params, the successful response will be an object with a single key links which is an array of mentions matching the type below:

type TMention = {
  source: string
  verified: boolean
  verified_date: string // date string
  id: number
  private: boolean
  data: {
    author: {
      name: string
      url: string
      photo: string // url, hosted in webmention.io
    }
    url: string
    name: string
    content: string // encoded HTML
    published: string // date string
    published_ts: number // ms
  }
  activity: {
    type: 'link' | 'reply' | 'repost' | 'like'
    sentence: string // pure text, shortened
    sentence_html: string // encoded html
  }
  target: string
}

The above data is more than enough to show a comment-like section list on our site. Here’s how the fetch request looks in TypeScript:

const getMentions = async (
  page: string,
  postsPerPage: number,
  postURL: string
): { links: TWebMention[] } => {
  const resp = await fetch(
    `https://webmention.io/api/mentions?page=${page}&per-page=${postsPerPage}&target=${postURL}`
  )
  const list = await resp.json()
  return list.links
}

Hook it all up in NextJS

We’re going to work in NextJS for a moment. It’s all good if you aren’t using NextJS or even have a web app. We already have all the data, so those of you not working in NextJS can simply move ahead to Step 4. The rest of us will meet you there.

As of version 9.3.0, NextJS has three different methods for fetching data:

1. getStaticProps: fetches data on build time
2. getStaticPaths: specifies dynamic routes to pre-render based on the fetched data
3. getServerSideProps: fetches data on each request

Now is the moment to decide at which point we will be making the first request for fetching mentions. We can pre-render the data on the server with the first batch of mentions, or we can make the entire thing client-side. I opted to go client-side.

If you’re going client-side as well, I recommend using SWR. It’s a custom hook built by the Vercel team that provides good caching, error and loading states — it and even supports React.Suspense.

Display the Webmention count

Many blogs show the number of comments on a post in two places: at the top of a blog post (like this one) and at the bottom, right above a list of comments. Let’s follow that same pattern for Webmentions.

First off, let’s create a component for the count:

const MentionsCounter = ({ postUrl }) => {
  const { t } = useTranslation()
  // Setting a default value for `data` because I don't want a loading state
  // otherwise you could set: if(!data) return <div>loading...</div>
  const { data = {}, error } = useSWR(postUrl, getMentionsCount)


  if (error) {
    return <ErrorMessage>{t('common:errorWebmentions')}</ErrorMessage>
  }


  // The default values cover the loading state
  const { likes = '-', mentions = '-' } = data


  return (
    <MentionCounter>
      <li>
        <Heart title="Likes" />
        <CounterData>{Number.isNaN(likes) ? 0 : likes}</CounterData>
      </li>
      <li>
        <Comment title="Mentions" />{' '}
        <CounterData>{Number.isNaN(mentions) ? 0 : mentions}</CounterData>
      </li>
    </MentionCounter>
  )
}

Thanks to SWR, even though we are using two instances of the WebmentionsCounter component, only one request is made and they both profit from the same cache.

Feel free to peek at my source code to see what’s happening:

• WebmentionsCounter (the component)
• getMentionsCount (the helper function)
• Post layout component (where we’re using the component)

Display the mentions

Now that we have placed the component, it’s time to get all that social juice flowing!

At of the time of this writing, useSWRpages is not documented. Add to that the fact that the webmention.io endpoint doesn’t offer collection information on a response (i.e. no offset or total number of pages), I couldn’t find a way to use SWR here.

So, my current implementation uses a state to keep the current page stored, another state to handle the mentions array, and useEffect to handle the request. The “Load More” button is disabled once the last request brings back an empty array.

const Webmentions = ({ postUrl }) => {
  const { t } = useTranslation()
  const [page, setPage] = useState(0)
  const [mentions, addMentions] = useState([])


  useEffect(() => {
    const fetchMentions = async () => {
      const olderMentions = await getMentions(page, 50, postUrl)
      addMentions((mentions) => [...mentions, ...olderMentions])
    }
    fetchMentions()
  }, [page])


  return (
    <>
      {mentions.map((mention, index) => (
        <Mention key={mention.data.author.name + index}>
          <AuthorAvatar src={mention.data.author.photo} lazy />
          <MentionContent>
            <MentionText
              data={mention.data}
              activity={mention.activity.type}
            />
          </MentionContent>
        </Mention>
      ))}
      </MentionList>
      {mentions.length > 0 && (
        <MoreButton
          type="button"
          onClick={() => {
          setPage(page + 1)
        }}
        >
        {t('common:more')}
      </MoreButton>
    )}
    </>
  )
}

The code is simplified to allow focus on the subject of this article. Again, feel free to peek at the full implementation:

• Webmention component
• getMentions helper
• Posts layout component

Step 4: Handling outbound mentions

Thanks to Remy Sharp, handling outbound mentions from one website to others is quite easy and provides an option for each use case or preference possible.

The quickest and easiest way is to head over to Webmention.app, get an API token, and set up a web hook. Now, if you have RSS feed in place, the same thing is just as easy with an IFTT applet, or even a deploy hook.

If you prefer to avoid using yet another third-party service for this feature (which I totally get), Remy has open-sourced a CLI package called wm which can be ran as a postbuild script.

But that’s not enough to handle outbound mentions. In order for our mentions to include more than simply the originating URL, we need to add microformats to our information. Microformats are key because it’s a standardized way for sites to distribute content in a way that Webmention-enabled sites can consume.

At their most basic, microformats are a kind of class-based notations in markup that provide extra semantic meaning to each piece. In the case of a blog post, we will use two kinds of microformats:

• h-entry: the post entry
• h-card: the author of the post

Most of the required information for h-entry is usually in the header of the page, so the header component may end up looking something like this:

<header class="h-entry">
  <!-- the post date and time -->
  <time datetime="2020-04-22T00:00:00.000Z" class="dt-published">
    2020-04-22
  </time>
  <!-- the post title -->
  <h1 class="p-name">
    Webmentions with NextJS
  </h1>
</header>

And that’s it. If you’re writing in JSX, remember to replace class with className, that datetime is camelCase (dateTime), and that you can use the new Date('2020-04-22').toISOString() function.

It’s pretty similar for h-card. In most cases (like mine), author information is below the article. Here’s how my page’s footer looks:

<footer class="h-card">
  <!-- the author name -->
  <span class="p-author">Atila Fassina</span>
  <!-- the authot image-->
  <img
    alt="Author's photograph: Atila Fassina"
    class="u-photo"
    src="/images/internal-avatar.jpg"
    lazy
  />
</footer>

Now, whenever we send an outbound mention from this blog post, it will display the full information to whomever is receiving it.

Wrapping up

I hope this post has helped you getting to know more about Webmentions (or even about IndieWeb as a whole), and perhaps even helped you add this feature to your own website or app. If it did, please consider sharing this post to your network. I will be super grateful! ?

References

• Using Web Mentions on Static Sites (Max Böck)
• Client-side Webmentions (Swyx)
• Send outgoing Webmentions (Remy Sharp)
• Your first webmention (Aaron Parecki)

Further reading

• Webmention W3C Specification (Recommendation)
• Webmention.io
• Webmention.App
• Outbound WebMentions CLI
• Bridgy
• Microformats.org
• IndieWeb

The post Jumping Into Webmentions With NextJS (or Not) appeared first on CSS-Tricks.

After just playing with apsect-ratio and being pleasantly surprised at how intuitive it is, here’s an example of CSS acting unintuitively:

If you have a fixed element on your page, which means it doesn’t move when you scroll, you might realise that it no longer acts fixed if you apply a CSS filter on its nearest ancestor. Go ahead, try it on the CodePen.

This is because applying a filter on the fixed element’s immediate parent makes it becoming the containing block instead of the viewport.

Hui Jing has more to teach in there about scrolling, rendering performance, and trickery with using pseudo elements to avoid issues.

I find this kind of thing among the most challenging CSS concepts to wrap my mind around, like Block Formatting Contexts (BFCs). A BFC Is A Mini Layout In Your Layout. ?

Direct Link to Article — Permalink

The post On fixed elements and backgrounds appeared first on CSS-Tricks.

No, that isn’t a doctor talking. That is an artificial intelligence-driven (AI) chatbot, which is giving patients new ways to deal with getting the correct consideration at their place of need. Chatbots take on an assortment of structures.

Their assignments fluctuate and may incorporate robotizing manual capacities for both healthcare providers and patients, giving day in and day out care, offering enthusiastic and physical prosperity support, expanding treatment adherence, and more.

For healthcare providers and patients, this is a win-win. Patient-driven outcomes are the goal, and AI chatbots can vastly improve healthcare functions and patient engagement, and ultimately, financial and healthcare results.

In this day and age of instant gratification, individuals need fast solutions and healthcare isn’t an exception. They would prefer not to hold up in long lines outside the center or medical clinic and they need a platform that keeps them updated on their issues all day, every day. Along these lines, AI and AI-empowered chatbots for healthcare are coordinated into applications and sites and they are turning into a favored decision for both the human services specialist co-ops and patients. Here is a gander at why the healthcare industry is going to AI and chatbot for persistent consideration.

AI and Healthcare

Artificial intelligence and chatbot have surprised numerous industries and like the various businesses, healthcare is going to observe perspective changes. Chatbot and healthcare mobile applications have just limited human mediation in the medical clinic enrollment, counsel, and charging process in numerous pieces of the United States. This is as of now an incredible help to the older patients and children who can and should possibly visit the specialist when in critical need only. Additionally, in the present quick paced life, the hold up is unsatisfactory. Thusly, chatbots are being actualized in most of the regular checkup applications and self-drug applications, for example, WebMD, Epocrates, and First Aid – American Red Cross.

Mobile Prescription and First Aid

Mobile app development for healthcare has helped patients to move on to mobile prescription stages where the specialists can educate them on the premise regarding their indications through video calls and messages. Be that as it may, this is just the situation with non-difficult issues, for example, normal diseases, fever, little wounds, and so on. On account of extreme infections and mishaps, specialists can straightforwardly visit the patient, send an ambulance, or recommend certain tests for better conclusion and care. Indeed, even in the Indian subcontinent, understanding applications like Practo, DocsApp, BookMyDoctor, and Qikwell are quickly changing the healthcare industry. A significant number of these applications offer data about a specialist’s accessibility in a particular medical clinic/private office, appointment booking, and online solutions. The applications team up with qualified specialists over all the significant major cities in the nation.

Then again, healthcare applications like First Aid – American Red Cross offer emergency treatment data on fingertips. The application is centered around advising the individuals about security tips in an outrageous climate alongside the emergency treatment in regular day to day existence and on account of mishaps. The application likewise has a crisis include that can straightforwardly encourage calls to 911 and Emergency Medical Services (EMS). The application has increased tremendous ubiquity in the United States and has in excess of 100,000 affirmed installations.

Self Medication and Drug Use

Another part of mobile AI is concentrating on people who are as of now very much aware of their wellbeing and prosperity. Such people want to maintain a strategic distance from a malady by identifying the manifestations and changing the way of life and taking medication in like manner. This is a decent methodology as a rule and it helps individuals in keeping up a sound way of life also. Certain applications center around this viewpoint and give data that is important and helpful. WebMD is a major name in this aspect as it to a great extent obliges the data situated crowd by giving exhaustive data on human services and sicknesses. The application includes a symptom checker, doctor dictionary, drug interaction checker, and numerous different tools that can support patients and individuals when all is said in done.

The future of AI Chatbots in Healthcare

Today, chatbots are at the cutting edge of business-to-customer correspondence. In 2019, the chatbot business arrived at a market estimation of $17.17 billion and is anticipated to reach $102.29 billion by 2025, and the healthcare industry will unquestionably notice through progressions.

1. PHYSICAL-FORM BOTS

AI chatbots may very well help patients with their healthcare requirements. A fully-functional AI-powered robot nurse has already started incorporating in the healthcare industry which can assist nurses with time-consuming, non-patient facing roles.

2. PATIENT-ENABLING BOTS

Mobilization Robots: At present, Honda’s Hoko Assist robot helps individuals incapacitated starting from the waist genuinely walk upstanding, though they would need to utilize a wheelchair in any case. Later on, such robots that make up for body parts may become standard and surpass seated assistants, for example, wheelchairs.

Staff-Assisting Robots: Health care center bots may gain enough empathy to be able to instruct patients through physical therapy, help them with bedside care, and other tasks where staff might be short.

3. AI CHATBOT ADVANCEMENTS

Gamification: Chatbots may utilize wellbeing and treatment-related games, and prize patients which focus on treatment adherence.

Understanding New Disease States: ML-empowered chatbots can help HCPs with seeing new medicines in a split second. The PC will filter through important information to make recommendations. On the patient front, they will have the option to distinguish the top HCPs for offered sicknesses and get limitlessly improved substitute guidance when help is inaccessible.

Given the technology’s potential healthcare industry usage and cost-effectiveness, the healthcare industry will continue to advance and hone this new technology. Considering the humanism of existing chatbots, a vast improvement in their abilities to mimic humans in behavior and services is in the future forecast.

The Healthcare business has consistently battled with consistent patient engagement and issue management. Expanding consumerism and the ascent of AI and AI-empowered chatbots have decreased the distinctions in both the perspectives and it has pushed patients to not be compelled to pick among cost and adequacy.

When you’re designing a website, the single most important thing you can do is gather strong feedback, so your team knows what’s approved, what needs improvement, and what direction to take the project.

Unfortunately, the most important group to gather feedback from, your stakeholders, is also all-too-often the least technically able.

BugHerd should be your primary tool for gathering website feedback, especially from non-technical users, because it’s perfected and simplified the feedback process; stakeholders can communicate their thoughts and ideas effectively, in a way that syncs beautifully with how your team prefers to work.

Like Adding Digital Sticky Notes To Your Screen

The web is awash with clichés about designers. One of the most commonly repeated is the image of a team of designers standing around discussing a wall of sticky notes, moving them around, adding a few, removing others.

Do you know why designers and sticky notes are such a cliché? Because they work! Sticking little yellow notes to designs has been an integral part of design crits for decades. It’s a tried-and-trusted method of hammering out the fine details of a design.

What BugHerd has done, with enormous success, is create a digital form of every design agency’s favorite feedback technique.

With BugHerd, your clients don’t need to know technical terms, they just point, click, and type a comment. It’s super-easy. We’ve found that using BugHerd not only speeds up the process of feedback and QA, but it actually opens up new creative directions, because when clients are comfortable with the communication tool, they’re free to bring their expertise to the table.

Just about anyone can use BugHerd, and while many users in management roles struggle with technology, we’ve found that they enjoy using BugHerd because they’re able to forget the tool, and focus on what they want to say. And when clients enjoy working with you on a project, magic happens.

Everything You Need to Get the Job Done

We all know stakeholders are busy, probably not as busy as you, but they certainly don’t have time to type essay-length emails every few days. And the last thing you want to do when a client is feeling frustrated is call them up to find out what they meant by “the widget on the left” or “the greyest box”.

Even worse, how many times have you been on a conference call, as someone struggles to describe a bug they’ve found that you just can’t reproduce. (Nine times out of ten, it’s that dodgy ad-blocker they installed anyway, right?)

Well, BugHerd has your back here. When someone pins a task onto a page BugHerd appends meta data about the issue, including CSS selector data, and a browser profile. On premium plans you even get automated screen shots. With just one point and click BugHerd gathers everything you need to reproduce, and resolve the issue, fuss free.

Should your client want to send extra feedback, that’s possible as well. BugHerd allows users to annotate screenshots with as much design feedback as they wish — so they can ask you to make the logo bigger, as if we don’t all take that one as read.

BugHerd makes it easy for your clients to communicate what they mean, with nothing lost in translation, making your revision process more streamlined, and your life easier.

A Secure System for Remote Teams

BugHerd’s an awesome tool for non-technical users, but just because stakeholders love its point and click, doesn’t mean it isn’t a powerful tool for you.

BugHerd passes all of its tasks into a customizable Kanban board. On top of that BugHerd integrates with the 3rd-party tools you’re probably already using including GitHub, JIRA, Zapier, Basecamp, Zendesk, and Slack. And for seriously committed power-users, you can even access your task list via BugHerd’s API. However your team works, BugHerd will fit right in.

BugHerd is the ideal feedback tool for remote working. It cuts out all of the miscommunication, and keeps your entire team on the same page. But if adding a layer of easy-access sticky notes to your website sounds like a recipe for disaster, rest assured it is strictly limited to those users you invite.

Short of a face-to-face meeting with actual sticky notes, BugHerd is the most effective way of enabling your clients to give you the feedback you need to meet their goals.

Try BugHerd for Free

BugHerd is packed with incredible features. But sometimes, there’s just no substitute for trying something out yourself. That’s why BugHerd offers a free 14-day trial. Meaning you can afford to sign-up, introduce your stakeholders and your team to the app, and judge for yourself.

A word of warning though: once you see how painless website feedback and revisions are with BugHerd, you won’t ever want to go back to those email chains.

Head over to BugHerd.com today, to claim your free 14-day trial, no credit card upfront.

[– This is a sponsored post on behalf of BugHerd –]

Source

{
"login": "hacktivist123",
"id": 26572907,
"node_id": "MDQ6VXNlcjI2NTcyOTA3",
"avatar_url": "https://avatars3.githubusercontent.com/u/26572907?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/hacktivist123",
"html_url": "https://github.com/hacktivist123",
"followers_url": "https://api.github.com/users/hacktivist123/followers",
"following_url": "https://api.github.com/users/hacktivist123/following{/other_user}",
"gists_url": "https://api.github.com/users/hacktivist123/gists{/gist_id}",
"starred_url": "https://api.github.com/users/hacktivist123/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/hacktivist123/subscriptions",
"organizations_url": "https://api.github.com/users/hacktivist123/orgs",
"repos_url": "https://api.github.com/users/hacktivist123/repos",
"events_url": "https://api.github.com/users/hacktivist123/events{/privacy}",
"received_events_url": "https://api.github.com/users/hacktivist123/received_events",
"type": "User",
"site_admin": false,
"name": "Shedrack akintayo",
"company": null,
"blog": "https://sheddy.xyz",
"location": "Lagos, Nigeria ",
"email": null,
"hireable": true,
"bio": "☕ Software Engineer | | Developer Advocate🥑|| ❤ Everything JavaScript",
"public_repos": 68,
"public_gists": 1,
"followers": 130,
"following": 246,
"created_at": "2017-03-21T12:55:48Z",
"updated_at": "2020-05-11T13:02:57Z"
} 

fetch('https://api.github.com/users/hacktivist123/repos')
  .then(response => response.json())
  .then(data => console.log(data));

import React from 'react';

class myComponent extends React.Component {
  componentDidMount() {
    const apiUrl = 'https://api.github.com/users/hacktivist123/repos';
    fetch(apiUrl)
      .then((response) => response.json())
      .then((data) => console.log('This is your data', data));
  }
  render() {
    return <h1>my Component has Mounted, Check the browser 'console' </h1>;
  }
}
export default myComponent;

npx create-react-app myRepos

npm start

import React from 'react';
const List = (props) => {
  const { repos } = props;
  if (repos.length === 0 || !repos) return <p>No repos, sorry</p>;
  return (
    <ul>
      <h2 className='list-head'>Available Public Repositories</h2>
      {repos.map((repo) => {
        return (
          <li key={repo.id} className='list'>
            <span className='repo-text'>{repo.name} </span>
            <span className='repo-description'>{repo.description}</span>
          </li>
        );
      })}
    </ul>
  );
};
export default List;

const { repos } = props;

if (repos.length === 0 || !repos) return <p>No repos, sorry</p>;

return (
    <ul>
      <h2 className='list-head'>Available Public Repositories</h2>
      {repos.map((repo) => {
        return (
          <li key={repo.id} className='list'>
            <span className='repo-text'>{repo.name} </span>
            <span className='repo-description'>{repo.description}</span>
          </li>
        );
      })}
    </ul>
  );

export default List;

import React from 'react';

function WithListLoading(Component) {
  return function WihLoadingComponent({ isLoading, ...props }) {
    if (!isLoading) return <Component {...props} />;
    return (
      <p style={{ textAlign: 'center', fontSize: '30px' }}>
        Hold on, fetching data may take some time :)
      </p>
    );
  };
}
export default WithListLoading;

import React, { useEffect, useState } from 'react';
import './App.css';
import List from './components/List';
import withListLoading from './components/withListLoading';
function App() {
  const ListLoading = withListLoading(List);
  const [appState, setAppState] = useState({
    loading: false,
    repos: null,
  });

  useEffect(() => {
    setAppState({ loading: true });
    const user = `https://api.github.com/users/hacktivist123/repos`;
    fetch(user)
      .then((res) => res.json())
      .then((repos) => {
        setAppState({ loading: false, repos: repos });
      });
  }, [setAppState]);
  return (
    <div className='App'>
      <div className='container'>
        <h1>My Repositories</h1>
      </div>
      <div className='repo-container'>
        <ListLoading isLoading={appState.loading} repos={appState.repos} />
      </div>
      <footer>
        <div className='footer'>
          Built{' '}
          <span role='img' aria-label='love'>
            💚
          </span>{' '}
          with by Shedrack Akintayo
        </div>
      </footer>
    </div>
  );
}
export default App;

import React, { useEffect, useState } from 'react';
import './App.css';
import List from './components/List';
import withListLoading from './components/withListLoading';

const ListLoading = withListLoading(List);
  const [appState, setAppState] = useState({
    loading: false,
    repos: null,
  });

useEffect(() => {
    setAppState({ loading: true });
    const user = `https://api.github.com/users/hacktivist123/repos`;
    fetch(user)
      .then((res) => res.json())
      .then((repos) => {
        setAppState({ loading: false, repos: repos });
      });
  }, [setAppState]);

return (
    <div className='App'>
      <div className='container'>
        <h1>My Repositories</h1>
      </div>
      <div className='repo-container'>
        <ListLoading isLoading={AppState.loading} repos={AppState.repos} />
      </div>
    </div>
  );
}
export default App;

@import url('https://fonts.googleapis.com/css2?family=Amiri&display=swap');
:root {
  --basic-color: #23cc71;
}
.App {
  box-sizing: border-box;
  display: flex;
  justify-content: center;
  align-items: center;
  flex-direction: column;
  font-family: 'Amiri', serif;
  overflow: hidden;
}
.container {
  display: flex;
  flex-direction: row;
}
.container h1 {
  font-size: 60px;
  text-align: center;
  color: var(--basic-color);
}
.repo-container {
  width: 50%;
  height: 700px;
  margin: 50px;
  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
  overflow: scroll;
}
@media screen and (max-width: 600px) {
  .repo-container {
    width: 100%;
    margin: 0;
    box-shadow: none;
  }
}
.repo-text {
  font-weight: 600;
}
.repo-description {
  font-weight: 600;
  font-style: bold;
  color: var(--basic-color);
}
.list-head {
  text-align: center;
  font-weight: 800;
  text-transform: uppercase;
}
.footer {
  font-size: 15px;
  font-weight: 600;
}
.list {
  list-style: circle;
}

// Make a GET request
axios({
  method: 'get',
  url: 'https://api.github.com/users/hacktivist123',
});

// Make a Post Request
axios({
  method: 'post',
  url: '/login',
  data: {
    firstName: 'shedrack',
    lastName: 'akintayo'
  }
});

// Make a GET request with a shorthand method
axios.get('https://api.github.com/users/hacktivist123');

// Make a Post Request with a shorthand method
axios.post('/signup', {
    firstName: 'shedrack',
    lastName: 'akintayo'
});

axios.all([
  axios.get('https://api.github.com/users/hacktivist123'),
  axios.get('https://api.github.com/users/adenekan41')
])
.then(response => {
  console.log('Date created: ', response[0].data.created_at);
  console.log('Date created: ', response[1].data.created_at);
});

npm install axios

yarn add axios

import axios from 'axios'

useEffect(() => {
    setAppState({ loading: true });
    const reposUrl = 'https://api.github.com/users/hacktivist123/repos';
    axios.get(user).then((repos) => {
      const allRepos = repos.data;
      setAppState({ loading: false, repos: allRepos });
    });
  }, [setAppState]);

axios.get(user).then((repos) => {
      const allRepos = repos.data;
      setAppState({ loading: false, repos: allRepos });
    });