Marcelo Kapi

1600547220

Create reusable Svelte components for your page layouts

In this tutorial, we will implement a Svelte component that serves as a structure for our project’s pages. It comes in handy when our pages have similar layouts and we want to react to content scroll.

The structure we will build here is composed by:

  • main content: scrollable
  • header: fixed on top of the page
  • footer: fixed on bottom of the page

We can obviously adapt the component to our needs. You can skip to the end if you only want the complete component code.

#design #programming #javascript #web-development #svelte

What is GEEK

Buddha Community

Create reusable Svelte components for your page layouts

Getting Started Building a Svelte App with SvelteKit

Svelte is a lightweight framework for building web applications. When you use it, it looks and feels a lot like other frontend frameworks like React and Vue, but leaves the virtual DOM behind. That, along with other optimisations means it does far less work in the browser, optimising user experience and load time.

In this guide, we'll be going over how to setup your first Svelte application using SvelteKit. Svelte has a number of different ways to make applications, and SvelteKit is one of the official packages from Svelte for doing that. If you're interested in other frameworks, you might enjoy a similar guide we have on making your first Vue application.

#Creating your first Svelte Application

To get started, open up a new terminal window and initiate your svelte application using the command below. Note if you don't have npm installed, you'll need to get it. You can install npm by installing Node.JS, via the link here.

Once you have Node.JS and NPM installed, run the command below. Before you do that though, make sure you use cd to move into the folder you want to create your new Svelte application in.

npm init svelte@next my-svelte-app

When you run this command, you'll auto generate a Svelte template in a folder called my-svelte-app. Svelte will guide you through a number of options. Select your preferences. The image below shows the one's I have selected. For the purposes of this guide, I will be using the Skeleton project.

Options for Selecting in SvelteKit

Finally, run the following command to cd into your svelte directory:

cd my-svelte-app

And then install all of your dependencies using the following line:

npm i

#Svelte File Structure

If you are familiar with other frameworks, then Svelte will feel familiar. Here is an overview of the file structure in Svelte, for the project we have just made:

static                 <-- where we store all of our public assets like favicons, images, and fonts
|- favicon.png         <-- our favicon
tests                  <-- a folder to store our tests
|- test.js             <-- an example test using @playwright
src                    <-- our main Svelte app files
|- routes              <-- a folder to store all of our routes in
|-- index.svelte       <-- our index route file. This will be the file displayed at the route of the site
|- app.d.ts            <-- our core Svelte app file
|- app.html            <-- our main index file where the app will appear
.gitignore             <-- files we wish to ignore for git
.npmrc                 <-- config file for npm
.prettierrc            <-- config file for prettier
.eslintrc.cjs          <-- config file for eslint
package.json           <-- our NPM installed packages
playwright.config.js   <-- config file for playwright
svelte.config.js       <-- config file for svelte itself
tsconfig.json          <-- config file for typescript

Our basic Svelte application is ready to go. If you want to see how it looks, you can serve it on your local computer on the URL http://localhost:3000 by running the following command in your Svelte application folder:

npm run dev

If you visit http://localhost:3000 in your browser, you should see something like this:

Our first Svelte Application

#Creating new pages or routes in Svelte

To make a new route in Sveltekit, simply make a new file within the routes folder. For example, if you make a file called about.svelte, then it will show up at http://localhost:3000/about. Another way you can do this is to make a new folder called about, and put index.svelte in that folder, http://localhost:3000/about will work.

#Try it yourself

Create a new page within your /src/routes folder, called about.svelte. Now when you go to http://localhost:3000/, you will be able to access that page. Similarly, you can try making a folder called about with a file placed inside called index.svelte

#How to run your SvelteKit App on Node.JS

To run your Svelte application on a server or locally on a Node.JS server, you need to use an adapter. If you want to run your Svelte application on a Node Server, install @sveltejs/adapter-node@next via the following line:

npm i @sveltejs/adapter-node@next 

Now we have to change our svelte.config.js file. We need to use the new adapter, and change our kit.adapter object within the config file. You can replace the contents of your svelte.config.js with the code below, but we're only changing two lines - our adapter import, and then adding the build directory in your config:

// We have changed the adapter line to use adapter-node@next
import adapter from '@sveltejs/adapter-node@next';
import preprocess from 'svelte-preprocess';

/** @type {import('@sveltejs/kit').Config} */
const config = {
	// Consult https://github.com/sveltejs/svelte-preprocess
	// for more information about preprocessors
	preprocess: preprocess(),

	kit: {
		// We have changed this to point to a build directory
		adapter: adapter({ out: 'build' })
	}
};

export default config;

#Other SvelteKit adapters

If you want to run your Svelte application on Cloudflare, Netlify, or Vercel, then you need to use one of these adapters, you don't need to do anything. These are all included by default in adapter-auto - so only change your svelte.config.js file if you aren't planning on using a Node.JS server.

#How to build your SvelteKit App for Production

Now that we've configured our adapter, let's build our application. In SvelteKit, it's easy to make your app ready to run in a production environment. Simply run the following command, which will create a new folder called .svelte-kit with all your production ready files in.

npm run build

Now, if you want to preview your production build, simply run the following command:

npm run preview

If you are running your application on a Node.JS server and have updated your adapter, as shown in the previous section, then you can run your new Svelte application locally by running the following command in your Svelte directory:

node build/index.js

Now when you navigate to http://localhost:3000/, your Svelte application should show, only this time it will be ready for production.

#Conclusion

In this guide we've looked at how to use SvelteKit to create your first Svelte application with routes. Let's look at what we've learned:

How to set up SvelteKit and create the basic structure of your Svelte application.

How to use routes in SvelteKit, so you can have multiple pages on your application.

How to update your config file to use the right adapter, based on where you want to deploy your application.

How to build and run your application locally on a Node.JS server.

Next, you can try playing around with Svelte to start customizing your application.

Source: https://hackernoon.com/getting-started-building-a-svelte-app-with-sveltekit

#svelte #sveltekit 

Marcelo Kapi

1600547220

Create reusable Svelte components for your page layouts

In this tutorial, we will implement a Svelte component that serves as a structure for our project’s pages. It comes in handy when our pages have similar layouts and we want to react to content scroll.

The structure we will build here is composed by:

  • main content: scrollable
  • header: fixed on top of the page
  • footer: fixed on bottom of the page

We can obviously adapt the component to our needs. You can skip to the end if you only want the complete component code.

#design #programming #javascript #web-development #svelte

How to Create Reusable Components in Svelte.

In this video I will be showing how easy it is to build reusable components in Svelte.

#svelte  #component 

Harry Patel

Harry Patel

1614145832

A Complete Process to Create an App in 2021

It’s 2021, everything is getting replaced by a technologically emerged ecosystem, and mobile apps are one of the best examples to convey this message.

Though bypassing times, the development structure of mobile app has also been changed, but if you still follow the same process to create a mobile app for your business, then you are losing a ton of opportunities by not giving top-notch mobile experience to your users, which your competitors are doing.

You are about to lose potential existing customers you have, so what’s the ideal solution to build a successful mobile app in 2021?

This article will discuss how to build a mobile app in 2021 to help out many small businesses, startups & entrepreneurs by simplifying the mobile app development process for their business.

The first thing is to EVALUATE your mobile app IDEA means how your mobile app will change your target audience’s life and why your mobile app only can be the solution to their problem.

Now you have proposed a solution to a specific audience group, now start to think about the mobile app functionalities, the features would be in it, and simple to understand user interface with impressive UI designs.

From designing to development, everything is covered at this point; now, focus on a prelaunch marketing plan to create hype for your mobile app’s targeted audience, which will help you score initial downloads.

Boom, you are about to cross a particular download to generate a specific revenue through your mobile app.

#create an app in 2021 #process to create an app in 2021 #a complete process to create an app in 2021 #complete process to create an app in 2021 #process to create an app #complete process to create an app

Developing Chatbots project

If you want your business to prosper, you'll have to stay on top of the latest trends. The creation of a chatbot is a lengthy procedure. However, if well planned, it can be a piece of cake. The emergence of chatbots is one of the most significant recent developments in the area of customer care. On that topic, chatbots are one of the most well-known marketing tools in use today, aiding in the development of effective communication between businesses and their customers. So, read on to learn about data science projects for final year students as well as data science projects for beginners.

When it comes to chatbot creation, the most important thing to remember is to break the process down into simple steps and follow them one by one. Chatbots are quite handy if you want to improve your customer's experience by answering their questions, reducing human workload, performing remote troubleshooting, and so on. Rather than adopting a bot development framework or another platform, why not build a basic, intelligent chatbot from the ground up using deep learning? Though bots have a wide range of applications, one of the most well-known is live chat platforms, where users ask queries and a chatbot responds appropriately. There are different types of recommendation systems of the data science projects ideas.

So, in order to make your life easier, we've provided step-by-step chatbot programming guidelines. The days of waiting (not so patiently) on hold for answers to your most pressing questions are quickly fading away. In this lesson, you'll learn how to use Keras to create an end-to-end domain-specific intelligent chatbot solution.

Overview:

A chatbot is a piece of software that can communicate and conduct tasks in the same way that a human can. Because we're going to build a deep learning model, we'll need data to train it. Chatbots are marketing and automation solutions that are supposed to assist people by interacting with them and performing human-like interactions. Chatbots are widely utilised in customer service, social media marketing, and client instant messaging.

However, because this is a rudimentary chatbot, we will neither collect nor download any significant datasets. To communicate, these bots may employ Natural Language Processing (NLP) or audio analysis techniques, making them sound more natural. Based on how they're developed, there are two primary sorts of chatbot models: retrieval-based and generation-based models. These intentions may differ from one

chatbot solution to the next depending on the domain in which you are implementing a chatbot solution. AI-Chatbots are widely recommended by entrepreneurs and organizations. Let's take this data science project step by step.

Import and load the data file

import nltk

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

import json

import pickle

import numpy as np

from keras.models import Sequential

from keras.layers import Dense, Activation, Dropout

from keras.optimizers import SGD

import random

words=[]

classes = []

documents = []

ignore_words = ['?', '!']

data_file = open('intents.json').read()

intents = json.loads(data_file)

Preprocess data 

for intent in intents['intents']:

    for pattern in intent['patterns']:

     #tokenize each word

     w = nltk.word_tokenize(pattern)

     words.extend(w)

     #add documents in the corpus

     documents.append((w, intent['tag']))

           if intent['tag'] not in classes:

         classes.append(intent['tag'])

Create training and testing data 

training = []

 

output_empty = [0] * len(classes)

 

for doc in documents:

  

    bag = []

Build the model

model = Sequential()

model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(64, activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(len(train_y[0]), activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)

model.save('chatbot_model.h5', hist)

print("model created"

 output_row = list(output_empty)

    output_row[classes.index(doc[1])] = 1

    training.append([bag, output_row])

random.shuffle(training)

training = np.array(training)

train_x = list(training[:,0])

train_y = list(training[:,1])

print("Training data created")

Predict the response (Graphical User Interface)

import nltk

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

import pickle

import numpy as np

from keras.models import load_model

model = load_model('chatbot_model.h5')

import json

import random

intents = json.loads(open('intents.json').read())

words = pickle.load(open('words.pkl','rb'))

def clean_up_sentence(sentence):

sentence_words = nltk.word_tokenize(sentence)

 return sentence_words

def bow(sentence, words, show_details=True):

 sentence_words = clean_up_sentence(sentence)

bag = [0]*len(words)

    for s in sentence_words:

     for i,w in enumerate(words):

         if w == s:

             bag[i] = 1

             if show_details:

                 print ("found in bag: %s" % w)

    return(np.array(bag))

def predict_class(sentence, model):

 p = bow(sentence, words,show_details=False)

    res = model.predict(np.array([p]))[0]

    ERROR_THRESHOLD = 0.25

     results.sort(key=lambda x: x[1], reverse=True)

    return_list = []

    for r in results:

        return_list.append({"intent": classes[r[0]], "probability": str(r[1])})

    return return_list

.def getResponse(ints, intents_json):

    tag = ints[0]['intent']

    list_of_intents = intents_json['intents']

    for i in list_of_intents:

     if(i['tag']== tag):

         result = random.choice(i['responses'])

         break

    return result

def chatbot_response(text):

    ints = predict_class(text, model)

    res = getResponse(ints, intents)

    return res

#Creating GUI with tkinter

import tkinter

from tkinter import *

def send():

    msg = EntryBox.get("1.0",'end-1c').strip()

    EntryBox.delete("0.0",END)

    if msg != '':

     ChatLog.config(state=NORMAL)

     ChatLog.insert(END, "You: " + msg + '\n\n')

     ChatLog.config(foreground="#442265", font=("Verdana", 12 ))

     res = chatbot_response(msg)

     ChatLog.insert(END, "Bot: " + res + '\n\n')

     ChatLog.config(state=DISABLED)

     ChatLog.yview(END)

base = Tk()

base.title("Hello")

base.geometry("400x500")

base.resizable(width=FALSE, height=FALSE)

#Create Chat window

ChatLog.config(state=DISABLED)

#Bind scrollbar to Chat window

scrollbar = Scrollbar(base, command=ChatLog.yview, cursor="heart")

ChatLog['yscrollcommand'] = scrollbar.set

#Create Button to send message

SendButton = Button(base, font=("Verdana",12,'bold'), text="Send", width="12", height=5,

                 bd=0, bg="#32de97", activebackground="#3c9d9b",fg='#ffffff',

                 command= send )

#Create the box to enter message

EntryBox = Text(base, bd=0, bg="white",width="29", height="5", font="Arial")

#EntryBox.bind("", send)

#Place all components on the screen

scrollbar.place(x=376,y=6, height=386)

ChatLog.place(x=6,y=6, height=386, width=370)

EntryBox.place(x=128, y=401, height=90, width=265)

SendButton.place(x=6, y=401, height=90)

base.mainloop()

If you want to learn more about how to do data science projects step by step, visit our website Learnbay: data science course in Chennai.

 

Keywords

Search Volume

Competition

data science project

17,480

25 (Low)

data science projects ideas

7,690

30 (Low)

data science project for final year

1,180

30(Low)

Data science project for beginners

7,500

26(Low)

data science projects step by step

2,240

31 (Low)