1660741784
Over the years, navigation bars, or navbars, have become a staple feature in building websites. They really come in handy for navigating across a website.
We will Create react navbar using advanced react js methods. In our previous tutorial, we have created a responsive navbar using basic react js. But in this tutorial we are going to use advance functionalities for creating this navbar using react js.
In this tutorial, we’ll go over the basics of building navbars in React. We’ll build a navbar that’s fixed to the top of the page, and the user will be able to switch between webpages like you can on a dashboard, for instance. We’ll then put all our newfound skills into practice by building a live sample app.
Our sample app is an animal gallery that we’ll use to view some pictures of different types of animals after we click the animal’s name on the navigation bar.
Let’s get right into the code. To create a React app, make sure you have Node.js installed on your computer. If you haven’t built a React app before, you can check to see if you have Node.js installed by typing the following into your terminal:
node -v
If not, just go to the Node.js website to download the latest version.
Once that’s done, we can get started with our React app by running this command:
npx create-react-app nav-bar
Then, we navigate into our project folder on the terminal:
cd nav-bar
Using the React Router library in our application allows us to navigate between different pages or components in React, and actually makes these changes to the URL of each page or component. In fact, it can also handle more complex functionalities, like passing data between pages through queries and nested routes — but that’s beyond the scope of this article.
For this example, we’ll only need to install the React Router library to help us switch views of the animals in our app when we click on the nav names on the links.
npm install react-router-dom
Code Sandbox: https://codesandbox.io/
Level 1(Previous Tutorial): https://youtu.be/23BHwAFIZmk
Source Code1: https://www.buymeacoffee.com/tech2etc/e/85299
Source Code2: https://ko-fi.com/s/7f02c9c3fd
Template & Setup(VS Code): https://github.com/tech2etc/React_Navbar_2
#react-native #react #nestjs #dom #htmlcss #web-development #dev
1660737060
Why
Web push requires that push messages triggered from a backend be done via the Web Push Protocol and if you want to send data with your push message, you must also encrypt that data according to the Message Encryption for Web Push spec.
This module makes it easy to send messages and will also handle legacy support for browsers relying on GCM for message sending / delivery.
Install
Installation is simple, just install via npm.
npm install web-push --save
Usage
The common use case for this library is an application server using a GCM API key and VAPID keys.
const webpush = require('web-push');
// VAPID keys should be generated only once.
const vapidKeys = webpush.generateVAPIDKeys();
webpush.setGCMAPIKey('<Your GCM API Key Here>');
webpush.setVapidDetails(
'mailto:example@yourdomain.org',
vapidKeys.publicKey,
vapidKeys.privateKey
);
// This is the same output of calling JSON.stringify on a PushSubscription
const pushSubscription = {
endpoint: '.....',
keys: {
auth: '.....',
p256dh: '.....'
}
};
webpush.sendNotification(pushSubscription, 'Your Push Payload Text');
When subscribing to push messages, you'll need to pass your VAPID key, which you can do like so:
registration.pushManager.subscribe({
userVisibleOnly: true,
applicationServerKey: '<Your Public Key from generateVAPIDKeys()>'
});
You can install web-push
globally and use it for sending notifications and / or generating VAPID keys.
Install like so:
npm install web-push -g
Then you can run the following commands:
Usage:
web-push send-notification --endpoint=<url> [--key=<browser key>] [--auth=<auth secret>] [--payload=<message>] [--encoding=<aesgcm | aes128gcm>] [--ttl=<seconds>] [--vapid-subject=<vapid subject>] [--vapid-pubkey=<public key url base64>] [--vapid-pvtkey=<private key url base64>] [--proxy=<http proxy uri>] [--gcm-api-key=<api key>]
web-push generate-vapid-keys [--json]
Example of send notification:
> web-push generate-vapid-keys --json
> {"publicKey":"BGtkbcjrO12YMoDuq2sCQeHlu47uPx3SHTgFKZFYiBW8Qr0D9vgyZSZPdw6_4ZFEI9Snk1VEAj2qTYI1I1YxBXE","privateKey":"I0_d0vnesxbBSUmlDdOKibGo6vEXRO-Vu88QlSlm5j0"}
The subscription value:
{
"endpoint": "https://fcm.googleapis.com/fcm/send/d61c5u920dw:APA91bEmnw8utjDYCqSRplFMVCzQMg9e5XxpYajvh37mv2QIlISdasBFLbFca9ZZ4Uqcya0ck-SP84YJUEnWsVr3mwYfaDB7vGtsDQuEpfDdcIqOX_wrCRkBW2NDWRZ9qUz9hSgtI3sY",
"expirationTime": null,
"keys": {
"p256dh": "BL7ELU24fJTAlH5Kyl8N6BDCac8u8li_U5PIwG963MOvdYs9s7LSzj8x_7v7RFdLZ9Eap50PiiyF5K0TDAis7t0",
"auth": "juarI8x__VnHvsOgfeAPHg"
}
}
The command example:
web-push send-notification \
--endpoint=https://fcm.googleapis.com/fcm/send/d61c5u920dw:APA91bEmnw8utjDYCqSRplFMVCzQMg9e5XxpYajvh37mv2QIlISdasBFLbFca9ZZ4Uqcya0ck-SP84YJUEnWsVr3mwYfaDB7vGtsDQuEpfDdcIqOX_wrCRkBW2NDWRZ9qUz9hSgtI3sY \
--key=BL7ELU24fJTAlH5Kyl8N6BDCac8u8li_U5PIwG963MOvdYs9s7LSzj8x_7v7RFdLZ9Eap50PiiyF5K0TDAis7t0 \
--auth=juarI8x__VnHvsOgfeAPHg \
--vapid-subject=mailto:example@qq.com \
--vapid-pubkey=BGtkbcjrO12YMoDuq2sCQeHlu47uPx3SHTgFKZFYiBW8Qr0D9vgyZSZPdw6_4ZFEI9Snk1VEAj2qTYI1I1YxBXE \
--vapid-pvtkey=I0_d0vnesxbBSUmlDdOKibGo6vEXRO-Vu88QlSlm5j0 \
--payload=Hello
API Reference
const pushSubscription = {
endpoint: '< Push Subscription URL >',
keys: {
p256dh: '< User Public Encryption Key >',
auth: '< User Auth Secret >'
}
};
const payload = '< Push Payload String >';
const options = {
gcmAPIKey: '< GCM API Key >',
vapidDetails: {
subject: '< \'mailto\' Address or URL >',
publicKey: '< URL Safe Base64 Encoded Public Key >',
privateKey: '< URL Safe Base64 Encoded Private Key >'
},
timeout: <Number>
TTL: <Number>,
headers: {
'< header name >': '< header value >'
},
contentEncoding: '< Encoding type, e.g.: aesgcm or aes128gcm >',
proxy: '< proxy server options >',
agent: '< https.Agent instance >'
}
webpush.sendNotification(
pushSubscription,
payload,
options
);
Note:
sendNotification()
you don't need to define a payload, and this method will work without a GCM API Key and / or VAPID keys if the push service supports it.
Push Subscription
The first argument must be an object containing the details for a push subscription.
The expected format is the same output as JSON.stringify'ing a PushSubscription in the browser.
Payload
The payload is optional, but if set, will be the data sent with a push message.
This must be either a string or a node Buffer.
Note: In order to encrypt the payload, the pushSubscription must have a keys object with p256dh and auth values.
Options
Options is an optional argument that if defined should be an object containing any of the following values defined, although none of them are required.
setGCMAPIKey()
.privateKey values defined. These values should follow the VAPID Spec.
https.request
method. If the proxy
options defined, agent
will be ignored!A promise that resolves if the notification was sent successfully with details of the request, otherwise it rejects.
In both cases, resolving or rejecting, you'll be able to access the following values on the returned object or error.
const vapidKeys = webpush.generateVAPIDKeys();
// Prints 2 URL Safe Base64 Encoded Strings
console.log(vapidKeys.publicKey, vapidKeys.privateKey);
None.
Returns an object with publicKey and privateKey values which are URL Safe Base64 encoded strings.
Note: You should create these keys once, store them and use them for all future messages you send.
webpush.setGCMAPIKey('Your GCM API Key');
This method expects the GCM API key that is linked to the gcm_sender_id
in your web app manifest.
You can use a GCM API Key from the Google Developer Console or the Cloud Messaging tab under a Firebase Project.
None.
const pushSubscription = {
endpoint: 'https://....',
keys: {
p256dh: '.....',
auth: '.....'
}
};
webPush.encrypt(
pushSubscription.keys.p256dh,
pushSubscription.keys.auth,
'My Payload',
'aes128gcm'
)
.then(encryptionDetails => {
});
Encrypts the payload according to the Message Encryption for Web Push standard.
(sendNotification will automatically encrypt the payload for you, so if you use sendNotification you don't need to worry about it).
The encrypt()
method expects the following input:
This method returns an object with the following fields:
const parsedUrl = url.parse(subscription.endpoint);
const audience = parsedUrl.protocol + '//' +
parsedUrl.hostname;
const vapidHeaders = vapidHelper.getVapidHeaders(
audience,
'mailto: example@web-push-node.org',
vapidDetails.publicKey,
vapidDetails.privateKey,
'aes128gcm'
);
The getVapidHeaders() method will take in the values needed to create an Authorization and Crypto-Key header.
The getVapidHeaders()
method expects the following input:
This method returns an object with the following fields:
const pushSubscription = {
endpoint: '< Push Subscription URL >';
keys: {
p256dh: '< User Public Encryption Key >',
auth: '< User Auth Secret >'
}
};
const payload = '< Push Payload String >';
const options = {
gcmAPIKey: '< GCM API Key >',
vapidDetails: {
subject: '< \'mailto\' Address or URL >',
publicKey: '< URL Safe Base64 Encoded Public Key >',
privateKey: '< URL Safe Base64 Encoded Private Key >',
}
TTL: <Number>,
headers: {
'< header name >': '< header value >'
},
contentEncoding: '< Encoding type, e.g.: aesgcm or aes128gcm >',
proxy: '< proxy server options >'
}
try {
const details = webpush.generateRequestDetails(
pushSubscription,
payload,
options
);
} catch (err) {
console.error(err);
}
Note: When calling
generateRequestDetails()
the payload argument does not need to be defined, passing in null will return no body and exclude any unnecessary headers. Headers related to the GCM API Key and / or VAPID keys will be included if supplied and required.
Push Subscription
The first argument must be an object containing the details for a push subscription.
The expected format is the same output as JSON.stringify'ing a PushSubscription in the browser.
Payload
The payload is optional, but if set, will be encrypted and a Buffer will be returned via the payload
parameter.
This argument must be either a string or a node Buffer.
Note: In order to encrypt the payload, the pushSubscription must have a keys object with p256dh and auth values.
Options
Options is an optional argument that if defined should be an object containing any of the following values defined, although none of them are required.
setGCMAPIKey()
.privateKey values defined. These values should follow the VAPID Spec.
An object containing all the details needed to make a network request, the object will contain:
Browser Support
Browser | Push without Payload | Push with Payload | VAPID | Notes |
---|---|---|---|---|
Chrome | ✓ v42+ | ✓ v50+ | ✓ v52+ | In v51 and less, the `gcm_sender_id` is needed to get a push subscription. |
Edge | ✓ v17+ (April 2018) | ✓ v17+ (April 2018) | ✓ v17+ (April 2018) | |
Firefox | ✓ v44+ | ✓ v44+ | ✓ v46+ | |
Opera | ✓ v39+ * | ✓ v39+ * | ✗ | * Opera supports push on Android but not on desktop. The `gcm_sender_id` is needed to get a push subscription. |
Safari | ✗ | ✗ | ✗ | |
Samsung Internet Browser | ✓ v4.0.10-53+ | ✓ v5.0.30-40+ | ✗ | The `gcm_sender_id` is needed to get a push subscription. |
Help
Service Worker Cookbook
The Service Worker Cookbook is full of Web Push examples using this library.
Running tests
Prerequisites:
- Java JDK or JRE (http://www.oracle.com/technetwork/java/javase/downloads/index.html)
To run tests:
npm test
Author: Web-push-libs
Source Code: https://github.com/web-push-libs/web-push
License: View license
1660528800
Escher has been repurposed to be a metapackage around Interact.jl and other packages for web deployment (so far it includes Mux.jl but more things may be added as they become available). Refer to the Interact documentation (in particular the deployment section).
You can replace using Interact, Mux
with using Escher
, i.e.:
using Escher
ui = @manipulate for i in 1:100
i
end
webio_serve(page("/", req -> ui))
Author: JuliaGizmos
Source Code: https://github.com/JuliaGizmos/Escher.jl
License: View license
1660386360
A library that contains widgets that utilize web specific code.
Run this command:
With Flutter:
$ flutter pub add touchkit_web
This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get
):
dependencies:
touchkit_web: ^0.0.1
Alternatively, your editor might support flutter pub get
. Check the docs for your editor to learn more.
Now in your Dart code, you can use:
import 'package:touchkit_web/touchkit_web.dart';
Original article source at: https://pub.dev/packages/touchkit_web
1660331580
A plugin to handle Web argon2 password hashing bindings in Flutter application.
Uses the Argon2 implementation from hash-wasm
This is ONLY the web-specific platform interface. Please use the federated dargon2_flutter plugin for hashing functionality, which provides mobile & web support
Run this command:
With Flutter:
$ flutter pub add dargon2_flutter_web
This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get
):
dependencies:
dargon2_flutter_web: ^3.1.0
Alternatively, your editor might support flutter pub get
. Check the docs for your editor to learn more.
Now in your Dart code, you can use:
import 'package:dargon2_flutter_web/dargon2_flutter_web.dart';
Author: Tmthecoder
Source Code: https://github.com/tmthecoder/dargon2
License: MIT license
1660288380
Web-based PostgreSQL database browser written in Go.
Pgweb is a web-based database browser for PostgreSQL, written in Go and works on OSX, Linux and Windows machines. Main idea behind using Go for backend development is to utilize ability of the compiler to produce zero-dependency binaries for multiple platforms. Pgweb was created as an attempt to build very simple and portable application to work with local or remote PostgreSQL databases.
Visit WIKI for more details
Pgweb Pro is the next major version of Pgweb and includes features like:
Please get in touch via: https://goo.gl/forms/euQOGWg5uPdPH70b2
Visit https://pgweb-demo.herokuapp.com to see pgweb in action.
Start server:
pgweb
You can also provide connection flags:
pgweb --host localhost --user myuser --db mydb
Connection URL scheme is also supported:
pgweb --url postgres://user:password@host:port/database?sslmode=[mode]
pgweb --url "postgres:///database?host=/absolute/path/to/unix/socket/dir"
To enable multiple database sessions in pgweb, start the server with:
pgweb --sessions
Or set environment variable:
SESSIONS=1 pgweb
Before running tests, make sure you have PostgreSQL server running on localhost:5432
interface. Also, you must have postgres
user that could create new databases in your local environment. Pgweb server should not be running at the same time.
Execute test suite:
make test
If you're using Docker locally, you might also run pgweb test suite against all supported PostgreSQL version with a single command:
make test-all
Author: sosedoff
Source Code: https://github.com/sosedoff/pgweb
License: MIT license
1660202939
Create your own DeFi crypto exchange with cutting edge features from the expert DeFi exchange development services company.
DeFi exchange platform development company
DeFi or open finance is one of the most talked about topics of the crypto market as it has captured a wide range of Fintech Industry and blockchain arena with large benefits. The system has disrupted the traditional finance procedures to an improvised decentralized platform that provides much needed solutions like services like quick loans, lending and borrowing etc. DeFi exchange development provides a variety of services like the ability to manage their own funds by the DeFi participants, easy earning by staking, yield farming and many more. One of the notable highlights of the DeFi crypto exchange platform is its superfast transaction speed and automated transactions with smart contracts DeFi exchange platform development company
As a pioneer Decentralised finance exchange development company, Shamla tech helps to create your own DeFi crypto exchange to bring together global traders by providing a permissionless and trustworthy defi platform.
No Intermediary
The lack of intermediary offers great trading experience with improved security and trustworthy peer to peer transactions
Smart Contracts
Smart contracts offer completely reliable and super fast trade with automated transactions also avoiding manual errors.
Top notch Security
The decentralised system upholds security and privacy to the data and funds eliminating the possibility of any hack or unauthorized activity.
Low fees
The transaction fees are cut down drastically without the influence of third parties assuring easy and cheaper cross border trade.
Liquidity
Defi for crypto exchange enhances the liquidity with robust automated liquidity protocols allowing trouble-free trading.
Control over funds
Defi based cryptocurrency exchanges facilitate total ownership to the buyer and seller over their funds and data.
Voting options
Usage of governance tokens in the platform helps build a frictionless financial framework with voting rights for the users.
Transparency
Decentralised exchanges are known for their transparency and this helps the users to avoid any disputes or fraud.
shamlatech is a one stop solution for all the cryptocurrency exchange development script and DeFi exchange development solutions to deal with every sector. We offer popular and trending P2P cryptocurrency exchange script developed skillfully by our developers. Our Decentralised finance based solutions are popular in this field and are experts in offering custom and scalable solutions of the desired platform.
Read more: DeFi exchange development solutions
#Defiexchange
#Defiexchangedevelopment
#Decentralized platform
1660187460
This Task View contains information about to use R and the world wide web together. The base version of R does not ship with many tools for interacting with the web. Thankfully, there are an increasingly large number of tools for interacting with the web. This task view focuses on packages for obtaining web-based data and information, frameworks for building web-based R applications, and online services that can be accessed from R. A list of available packages and functions is presented below, grouped by the type of activity. The rOpenSci Task View: Open Data provides further discussion of online data sources that can be accessed from R.
If you have any comments or suggestions for additions or improvements for this Task View, go to GitHub and submit an issue , or make some changes and submit a pull request . If you can’t contribute on GitHub, send Scott an email . If you have an issue with one of the packages discussed below, please contact the maintainer of that package. If you know of a web service, API, data source, or other online resource that is not yet supported by an R package, consider adding it to the package development to do list on GitHub .
Core Tools For HTTP Requests
There are three main packages that should cover most use cases of interacting with the web from R. crul is an R6-based HTTP client that provides asynchronous HTTP requests, a pagination helper, HTTP mocking via webmockr, and request caching for unit tests via vcr. crul targets R developers more so than end users. httr provides more of a user facing client for HTTP requests and differentiates from the former package in that it provides support for OAuth. Note that you can pass in additional curl options when you instantiate R6 classes in crul, and the config
parameter in httr. curl is a lower-level package that provides a closer interface between R and the libcurl C library , but is less user-friendly. curl underlies both crul and httr. curl may be useful for operations on web-based XML or to perform FTP operations (as crul and httr are focused primarily on HTTP). curl::curl()
is an SSL-compatible replacement for base R’s url()
and has support for http 2.0, SSL (https, ftps), gzip, deflate and more. For websites serving insecure HTTP (i.e. using the “http” not “https” prefix), most R functions can extract data directly, including read.table
and read.csv
; this also applies to functions in add-on packages such as jsonlite::fromJSON()
and XML::parseXML
. For more specific situations, the following resources may be useful:
download.file()
is a general purpose function that can be used to download a remote file. For SSL, the download()
function in downloader wraps download.file()
, and takes all the same arguments.read.table()
, read.csv()
, and friends, again assuming that the files are not hosted via SSL. An alternative is to use httr::GET
(or RCurl::getURL
) to first read the file into R as a character vector before parsing with read.table(text=...)
, or you can download the file to a local directory. rio (GitHub ) provides an import()
function that can read a number of common data formats directly from an https:// URL. The repmis function source_data()
can load and cache plain-text data from a URL (either http or https). That package also includes source_Dropbox()
for downloading/caching plain-text data from non-public Dropbox folders and source_XlsxData()
for downloading/caching Excel xlsx sheets.http://api.foo.org/?key=yourkey
; user/pass: http://username:password@api.foo.org
), or can be specified via commands in RCurl or httr. OAuth is the most complicated authentication process, and can be most easily done using httr. See the 6 demos within httr, three for OAuth 1.0 (linkedin, twitter, vimeo) and three for OAuth 2.0 (facebook, GitHub, google). ROAuth is a package that provides a separate R interface to OAuth. OAuth is easier to to do in httr, so start there. googleAuthR provides an OAuth 2.0 setup specifically for Google web services, and AzureAuth provides similar functionality for Azure Active Directory.Handling HTTP Errors/Codes
Parsing Structured Web Data
The vast majority of web-based data is structured as plain text, HTML, XML, or JSON (javascript object notation). Web service APIs increasingly rely on JSON, but XML is still prevalent in many applications. There are several packages for specifically working with these format. These functions can be used to interact directly with insecure webpages or can be used to parse locally stored or in-memory web files.
xml2::read_html()
is a good first function to use for importing HTML. htmltools provides functions to create HTML elements. htmltab (GitHub ) extracts structured information from HTML tables, similar to XML::readHTMLTable
of the XML package, but automatically expands row and column spans in the header and body cells, and users are given more control over the identification of header and body rows which will end up in the R table. The selectorgadget browser extension can be used to identify page elements. RHTMLForms reads HTML documents and obtains a description of each of the forms it contains, along with the different elements and hidden fields. scrapeR provides additional tools for scraping data from HTML documents. htmltidy (GitHub ) provides tools to “tidy” messy HTML documents. htm2txt uses regex to converts html documents to plain text by removing all html tags. Rcrawler does crawling and scraping of web pages.Tools for Working with URLs
httr::parse_url()
function can be used to extract portions of a URL. The RCurl::URLencode()
and utils::URLencode()
functions can be used to encode character strings for use in URLs. utils::URLdecode()
decodes back to the original strings. urltools (GitHub ) can also handle URL encoding, decoding, parsing, and parameter extraction.Tools for Working with Scraped Webpage Contents
Security
Other Useful Packages and Functions
webmock
. This package only helps mock HTTP requests, and returns nothing when requests match expectations. webmockr integrates with the HTTP packages crul and httr. See Testing for mocking with returned responses.application/x-www-form-urlencoded
as well as multipart/form-data
. mime (GitHub ) guesses the MIME type for a file from its extension. rsdmx provides tools to read data and metadata documents exchanged through the Statistical Data and Metadata Exchange (SDMX) framework. The package currently focuses on the SDMX XML standard format (SDMX-ML). robotstxt provides functions and classes for parsing robots.txt files and checking access permissions; spiderbar does the same. uaparserjs (GitHub ) uses the javascript “ua-parser” library to parse User-Agent HTTP headers. rjsonapi consumes APIs that Follow the JSON API Specification . rapiclient is a client for consuming APIs that follow the Open API format . restfulr models a RESTful service as if it were a nested R list.Cloud Computing and Storage
lapply()
for the Elastic Map Reduce (EMR) engine called emrlapply()
. It uses Hadoop Streaming on Amazon’s EMR in order to get simple parallel computation.Document and Code Sharing
imgur_upload()
to load images from literate programming documents.Data Analysis and Processing Services
Social Media Clients
Web Analytics Services
Web Services for R Package Development
Other Web Services
Fitness Apps: fitbitScraper (GitHub ) retrieves Fitbit data. RGoogleFit provides similar functionality for Google Fit .
Push Notifications: RPushbullet provides an easy-to-use interface for the Pushbullet service which provides fast and efficient notifications between computers, phones and tablets. pushoverr (GitHub ) can sending push notifications to mobile devices (iOS and Android) and desktop using Pushover . notifyme (GitHub ) can control Phillips Hue lighting.
Reference/bibliography/citation management: RefManageR imports and manage BibTeX and BibLaTeX references with RefManager. rorcid (GitHub ) is a programmatic interface the Orcid.org API, which can be used for identifying scientific authors and their publications (e.g., by DOI). rdatacite connects to DataCite , which manages DOIs and metadata for scholarly datasets. scholar provides functions to extract citation data from Google Scholar. rscopus provides functions to extract citation data from Elsevier Scopus APIs. Convenience functions are also provided for comparing multiple scholars and predicting future h-index values. mathpix convert an image of a formula (typeset or handwritten) via Mathpix webservice to produce the LaTeX code. zen4R provides an Interface to Zenodo REST API, including management of depositions, attribution of DOIs by ‘Zenodo’ and upload of files.
Literature: rplos is a programmatic interface to the Web Service methods provided by the Public Library of Science journals for search. europepmc connects to the Europe PubMed Central service. pubmed.mineR is a package for text mining of PubMed Abstracts that supports fetching text and XML from PubMed. jstor provides functions and helpers to import metadata, ngrams and full-texts from Data for Research service by JSTOR. aRxiv is a client for the arXiv API, a repository of electronic preprints for computer science, mathematics, physics, quantitative biology, quantitative finance, and statistics. roadoi provides an interface to the Unpaywall API for finding free full-text versions of academic papers. rcoreoa is an interface to the CORE API , a search interface for open access scholarly articles. rcrossref is an interface to Crossref’s API, crminer extracts full text from scholarly articles retrieved via Crossref’s Text and Data Mining service; fulltext is a general purpose package to search for, retrieve and extract full text from scholarly articles; and rromeo (GitHub ) is an interface to the SHERPA/RoMEO API , a database of scientific journal archival policies regarding pre-, post-print, and accepted manuscript.
Automated Metadata Harvesting: oai and OAIHarvester harvest metadata using the Open Archives Initiative Protocol for Metadata Harvesting (OAI-PMH) standard. rresync is a client for the ResourceSync framework , a sort of replacement for OAI-PMH.
Wikipedia: WikipediR (GitHub ) is a wrapper for the MediaWiki API, aimed particularly at the Wikimedia ‘production’ wikis, such as Wikipedia. WikidataR (GitHub ) can request data from Wikidata.org , the free knowledgebase. wikipediatrend (GitHub ) provides access to Wikipedia page access statistics. WikidataQueryServiceR is a client for the Wikidata Query Service .
bigrquery (GitHub ): An interface to Google’s bigquery.
sparkbq (GitHub ): Google BigQuery support for sparklyr.
cymruservices queries Team Cymru web security services.
datamart: Provides an S4 infrastructure for unified handling of internal datasets and web based data sources. Examples include dbpedia, eurostat and sourceforge.
discgolf (GitHub ) provides a client to interact with the API for the Discourse web forum platform. The API is for an installed instance of Discourse, not for the Discourse site itself.
rdpla ((GitHub)[https://github.com/ropensci/rdpla\]) works with the Digital Public Library of America API.
factualR: Thin wrapper for the Factual.com server API.
internetarchive: API client for internet archive metadata.
jSonarR: Enables users to access MongoDB by running queries and returning their results in data.frames. jSonarR uses data processing and conversion capabilities in the jSonar Analytics Platform and the JSON Studio Gateway , to convert JSON to a tabular format.
livechatR is a client for the LiveChat API .
mockaRoo (not on CRAN) uses the MockaRoo API to generate mock or fake data based on an input schema.
pivotaltrackR provides an interface to the API for Pivotal Tracker , an agile project management tool.
randNames (GitHub ) generates random names and personal identifying information using the https://randomapi.com/ API.
Rblpapi (GitHub ) is a client for Bloomberg Finance L.P. ROpenFIGI (GitHub ) provides an interface to Bloomberg’s OpenFIGI API.
rerddap: A generic R client to interact with any ERDDAP instance, which is a special case of OPeNDAP ( https://en.wikipedia.org/wiki/OPeNDAP ), or Open-source Project for a Network Data Access Protocol . Allows user to swap out the base URL to use any ERDDAP instance.
restimizeapi provides an interface to trading website estimize.com .
RForcecom: RForcecom provides a connection to Force.com and Salesforce.com.
Two packages, owmr and ROpenWeatherMap, work with the Open Weather Map API .
RSauceLabs (GitHub ) connects to SauceLabs .
RStripe provides an interface to Stripe , an online payment processor.
RZabbix links with the Zabbix network monitoring service API .
slackr (GitHub ) is a client for Slack.com messaging platform.
shutterstock (GitHub ) is to access Shutterstock library from R.
stackr (not on CRAN): An unofficial wrapper for the read-only features of the Stack Exchange API .
telegram (GitHub ) connects with the Telegram Bot API.
trelloR (GitHub ) connects to the Trello API .
tuber is a YouTube API client and tubern is a client for the YouTube Analytics and Reporting API
udapi connects to Urban Dictionary.
useRsnap (not on CRAN) provides an interface to the API for Usersnap , a tool for collecting feedback from web application users.
yummlyr (GitHub ) provides an interface to the Yummly recipe database.
zendeskR: This package provides a wrapper for the Zendesk API.
ZillowR is a client for the Zillow real estate service.
docuSignr provides an interface to the DocuSign Rest API .
giphyr is an R interface to the Giphy API for GIF’s
duckduckr is an R interface DuckDuckGo’s Instant Answer API
Maintainer: | Scott Chamberlain, Thomas Leeper, Patrick Mair, Karthik Ram, Christopher Gandrud |
Contact: | myrmecocystus at gmail.com |
Version: | 2020-06-08 |
URL: | https://CRAN.R-project.org/view=WebTechnologies |
Do not edit this README by hand. See CONTRIBUTING.md .
Author: Cran-task-views
Source Code: https://github.com/cran-task-views/WebTechnologies
1659775980
Fast, and friendly Bun web framework.
⚡️ Faster than Express.js by 8.5x on M1 Max
Named after my favorite VTuber (Shirakami Fubuki) and composer (Sasakure.UK) song KINGWORLD/白上フブキ(Original)
KingWorld is web framework built for Bun. It focuses on speed, and developer friendliness.
Borrowing concepts from many popular Node.js web frameworks, KingWorld has a very familiar API designed to easily get started while hiding complex abstractions, and embracing simplicity.
KingWorld can be heavily customized with the use of plugins.
Currently, you can take a look at these:
KingWorld is a web framework based on Bun.
bun add kingworld
Now create index.ts
, and place the following:
import KingWorld from 'kingworld'
new KingWorld()
.get("/", () => "🦊 Now foxing")
.listen(3000)
And run the server:
bun index.ts
Then simply open http://localhost:3000
in your browser.
Congrats! You have just create a new web server in KingWorld 🎉🎉
Common HTTP methods have a built-in methods for convenient usage:
app.get("/hi", () => "Hi")
.post("/hi", () => "From Post")
.put("/hi", () => "From Put")
.on("M-SEARCH", async () => "Custom Method")
.listen(3000)
// [GET] /hi => "Hi"
// [POST] /hi => "From Post"
// [PUT] /hi => "From Put"
// [M-SEARCH] /hi => "Custom Method"
To return JSON, simply return any serializable object:
app.get("/json", () => ({
hi: 'KingWorld'
}))
// [GET] /json => {"hi": "KingWorld"}
All values returned from handler will be transformed into Response
.
You can return Response
if you want to declaratively control the response.
app
.get("/number", () => 1)
.get("/boolean", () => true)
.get("/promise", () => new Promise((resovle) => resolve("Ok")))
.get("/response", () => new Response("Hi", {
status: 200
}))
// [GET] /number => "1"
// [GET] /boolean => "true"
// [GET] /promise => "Ok"
// [GET] /response => "Hi"
Files are also transformed to response. Simply return Bun.file
to serve static file.
app.get("/tako", () => Bun.file('./example/takodachi.png'))
To get path paramameters, prefix the path with a colon:
app.get("/id/:id", ({ params: { id } }) => id)
// [GET] /id/123 => 123
To ensure the type, simply pass a generic:
app.get<{
params: {
id: string
}
}>("/id/:id", ({ params: { id } }) => id)
// [GET] /id/123 => 123
Wildcards are also acceptable:
app.get("/wildcard/*", () => "Hi")
// [GET] /wildcard/ok => "Hi"
// [GET] /wildcard/abc/def/ghi => "Hi"
For custom 404 page, use default
:
app.get("/", () => "Hi")
.default(() => new Response("Not stonk :(", {
status: 404
}))
// [GET] / => "Not stonk :("
You can group multiple route with a prefix with group
:
app
.get("/", () => "Hi")
.group("/auth", app => {
app
.get("/", () => "Hi")
.post("/sign-in", ({ body }) => body)
.put("/sign-up", ({ body }) => body)
})
.listen(3000)
// [GET] /auth/sign-in => "Hi"
// [POST] /auth/sign-in => <body>
// [PUT] /auth/sign-up => <body>
Finally, you can decouple the route logic to a separate plugin.
import KingWorld, { type Plugin } from 'kingworld'
const hi: Plugin = (app) => app
.get('/hi', () => 'Hi')
const app = new KingWorld()
.use(hi)
.get('/', () => 'KINGWORLD')
.listen(3000)
// [GET] / => "KINGWORLD"
// [GET] /hi => "Hi"
Handler is a callback function that returns Response
. Used in HTTP method handler.
new KingWorld()
.get(
'/',
// This is handler
() => "KingWorld"
)
.listen(3000)
By default, handler will accepts two parameters: request
and store
.
// Simplified Handler
type Handler = (request: ParsedRequest, store: Instance['store']) => Response
const handler: Handler = (request: {
request: Request
query: ParsedUrlQuery
params: Record<string, string>
headers: Record<string, string>
body: Promise<string | Object>
responseHeaders: Headers
}, store: Record<any, unknown>)
Handler's request consists of
Request
]ParsedUrlQuery
]Record<string, string>
{}
/hi?name=fubuki&game=KingWorld
{ "name": "fubuki", "game": "KingWorld" }
Record<string, string>
]{}
app.get("/id/:name/:game")
/id/kurokami/KingWorld
{ "name": "kurokami", "game": "KingWorld" }
Record<string, string>
]Promise<string | Object>
]string
or Object
Content-Type: application/json
, and is deserializableHeader
]CORS
to response as a pluginStore is a singleton store of the application.
Is recommended for local state, reference of database connection, and other things that need to be available to be used with handler.
Store value if of 2 types:
new KingWorld()
.state('build', Math.random())
.ref('random', () => Math.random())
.get("/build", ({}, { build }) => build)
.get("/random", ({}, { random }) => random)
.listen(3000)
// [GET] /build => 0.5
// [GET] /build => 0.5 // Will have the same value as first request
// [GET] /date => 0.374
// [GET] /date => 0.785
// [GET] /date => 0.651
State will have any value assigned, eg. Function will be a function reference. However for ref, if a value is a function, it will be called once.
This is for convenient usage of complex logic assigning at the beginning of every request.
You can assign a function to ref by assigning another callback, however if you want to assign function, please use state
instead because function should be static.
// ❌ Function is assigned on every request
new KingWorld()
.ref('getRandom', () => () => Math.random())
.get("/random", ({}, { getRandom }) => getRandom())
// ✅ Function is assigned once
new KingWorld()
.state('getRandom', () => Math.random())
.get("/random", ({}, { getRandom }) => getRandom())
KingWorld accepts generic to type a store globally.
new KingWorld<{
store: {
build: number
random: number
}
}>()
.state('build', Math.random())
.ref('random', () => Math.random())
.get("/build", ({}, { build }) => build)
.get("/random", ({}, { random }) => random)
.listen(3000)
KingWorld request's lifecycle can be illustrate as the following:
Request -> onRequest -> route -> transform -> preHandler -> Response
The callback that assigned to lifecycle is called hook.
Handler
]Handler
]Lifecycle can be assigned with app.<lifecycle name>()
:
For example, assigning transform
to a request:
app
// ? Transform params 'id' to number if available
.transform(({ params }) => {
if(params.id)
params.id = +params.id
})
There's 2 type of hook
Route Handler
or app.<method>(path, handler, localHook)
app
// ? Global Hook
.transform(({ params }) => {
if(params.id)
params.id = +params.id + 1
})
.get(
"/id/:id/:name",
({ params: { id, name } }) => `${id} ${name}`,
// ? Local hook
{
transform: ({ params }) => {
if(params.name === "白上フブキ")
params.name = "Shirakami Fubuki"
}
}
)
.get("/new/:id", ({ params: { id, name } }) => `${id} ${name}`)
.listen(3000)
// [GET] /id/2/kson => "3 kson"
// [GET] /id/1/白上フブキ => "2 Shirakami Fubuki"
// [GET] /new/1/白上フブキ => "2 白上フブキ"
You can have multiple local hooks as well by assigning it as array:
app
.get(
"/id/:id/:name",
({ params: { id, name } }) => `${id} ${name}`,
{
transform: [
({ params }) => {
if(params.id)
params.id = +params.id + 1
},
({ params }) => {
if(params.name === "白上フブキ")
params.name = "Shirakami Fubuki"
}
]
}
)
.listen(3000)
// [GET] /id/2/kson => "3 kson"
// [GET] /id/1/白上フブキ => "2 Shirakami Fubuki"
// [GET] /new/1/白上フブキ => "2 白上フブキ"
Callback assign to lifecycle before routing.
As it's handle before routing, there's no params
, query
.
type PreRequestHandler = (request: Request, store: Store) => void
Lifecycle that assigned with PreRequestHandler
:
Callback assign to lifecycle after routing.
Accept same value as path handler, @see Handler
Lifecycle that assigned with Handler
:
Use to modify request's body, params, query before validation.
app
.get(
"/gamer/:name",
({ params: { name }, hi }) => hi(name),
// ? Local hook
{
transform: ({ params }) => {
if(params.name === "白上フブキ")
params.name = "Shirakami Fubuki"
params.hi = (name: string) => `Hi ${name}`
}
}
)
// [GET] /gamer/白上フブキ => "Shirakami Fubuki"
// [GET] /gamer/Botan => "Botan"
As body is lazily execute as promise, simply use .then
to modify body.
new KingWorld()
.post<{
body: {
id: number
username: string
}
}>(
'/gamer',
async ({ body }) => {
const { username } = await body
return `Hi ${username}`
},
{
transform: (request) => {
request.body = request.body.then((user) => {
user.id = +user.id
return user
})
}
}
)
.listen(8080)
Please use @kingworldjs/schema to handle typed-strict validation of incoming request.
import KingWorld from 'kingworld'
import schema, { S } from '@kingworldjs/schema'
new KingWorld()
.get('/id/:id', ({ request: { params: { id } } }) => id, {
transform: (request, store) {
request.params.id = +request.params.id
},
preHandler: schema({
params: S.object().prop('id', S.number().minimum(1).maximum(100))
})
})
.listen(3000)
// [GET] /id/2 => 2
// [GET] /id/500 => Invalid params
// [GET] /id/-3 => Invalid params
See @kingworldjs/schema for more detail about schema validation.
Handle request before executing path handler. If value is returned, the value will be the response instead and skip the path handler.
Schema validation is useful, but as it only validate the type sometime app require more complex logic than type validation.
For example: Checking value if value existed in database before executing the request.
import KingWorld, { S } from 'kingworld'
new KingWorld()
.post<{
body: {
username: string
}
}>('/id/:id', ({ request: { body }) => {
const { username } = await body
return `Hi ${username}`
}, {
preHandler: async ({ body }) => {
const { username } = await body
const user = await database.find(username)
if(user)
return user.profile
else
return Response("User doesn't exists", {
status: 400
})
}
})
.listen(3000)
Plugin is used to decouple logic into smaller function.
import KingWorld, { type Plugin } from 'kingworld'
const hi: Plugin = (app) => app
.get('/hi', () => 'Hi')
const app = new KingWorld()
.use(hi)
.get('/', () => 'KINGWORLD')
.listen(3000)
// [GET] / => "KINGWORLD"
// [GET] /hi => "Hi"
However, plugin can also be used for assigning new store
, and hook
making it very useful.
To register a plugin, simply add plugin into use
.
use
can accept 2 parameters:
Plugin
]Config?
] (Optional)const plugin: Plugin = (
app,
// Config (2nd paramters of `use`)
{ prefix = '/fbk' } = {}
) => app
.group(prefix, (app) => {
app.get('/plugin', () => 'From Plugin')
})
new KingWorld()
.use(app, {
prefix: '/fubuki'
})
To develop plugin with type support, Plugin
can accepts generic.
const plugin: Plugin<
// ? Typed Config
{
prefix?: string
},
// ? Same as KingWorld<{}>(), will extends current instance
{
store: {
fromPlugin: 'From Logger'
}
request: {
log: () => void
}
}
> = (app, { prefix = '/fbk' } = {}) =>
app
.state('fromPlugin', 'From Logger')
.transform(({ responseHeaders }) => {
request.log = () => {
console.log('From Logger')
}
responseHeaders.append('X-POWERED-BY', 'KINGWORLD')
})
.group(prefix, (app) => {
app.get('/plugin', () => 'From Plugin')
})
const app = new KingWorld<{
Store: {
build: number
date: number
}
}>()
.use(plugin)
.get('/', ({ log }) => {
log()
return 'KingWorld'
})
// [GET] /fbk/plugin => "From Plugin"
Since Plugin have a type declaration, all request and store will be fully type and extended from plugin.
For example:
// Before plugin registration
new KingWorld<{
Store: {
build: number
date: number
}
}>()
// After plugin registration
new KingWorld<{
Store: {
build: number
date: number
} & {
fromPlugin: 'From Logger'
}
Request: {
log: () => void
}
}>()
This will enforce type safety across codebase.
const app = new KingWorld<{
Store: {
build: number
date: number
}
}>()
.use(plugin)
.get('/', ({ log }) => {
// `log` get type declaration reference from `plugin`
log()
return 'KingWorld'
})
Sometime, when you develop local plugin, type reference from main instance is need, but not available after separation.
const plugin: Plugin = (app) =>
app
.get("/user/:id", ({ db, params: { id } }) =>
// ❌ Type Error: db is not defined or smth like that
db.find(id)
)
const app = new KingWorld<{
Store: {
database: Database
}
}>()
.state('db', database)
.use(plugin)
That's why plugin can accept the third generic for adding temporary local type but do not extend the main instance.
const plugin: Plugin<
{},
{},
// Same as KingWorld<Instance>
{
store: {
db: Database
}
}
> = (app) =>
app
.get("/user/:id", ({ db, params: { id } }) =>
// ✅ db is now typed
db.find(id)
)
const app = new KingWorld()
.state('db', database)
.use(plugin)
To create an async plugin, simply create an async function the return plugin.
const plugin = async (): Plugin => {
const db = await setupDatabase()
return (app) =>
app
.state('db', database)
.get("/user/:id", ({ db, params: { id } }) =>
// ✅ db is now typed
db.find(id)
)
}
const app = new KingWorld()
.state('db', database)
.use(plugin)
KingWorld can accepts named generic to type global instance.
For example, type-strict store.
const app = new KingWorld<{
Store: {
build: number
}
}>()
.state('build', 1)
KingWorld instance can accept generic of KingWorldInstance
export interface KingWorldInstance<
Store extends Record<string, any> = {},
Request extends Record<string, any> = {}
> {
Request?: Request
Store: Store
}
KingWorld is designed to be serverless, only one simple handle
is need to be assigned to serverless function.
This also be used to create simple test environment, by simply call handle
function.
import { describe, expect, it } from "bun:test"
const req = (path: string) => new Request(path)
describe('Correctness', () => {
it('[GET] /', async () => {
const app = new KingWorld().get('/', () => 'Hi')
const res = await app.handle(req('/'))
expect(await res.text()).toBe('Hi')
})
})
Sometime KingWorld doesn't perform well in some situation or has some bug, which can be related to Bun.
Notable reference:
However, if you're sure that the bug is related to KingWorld, filing an issue is always welcome.
For the current state of Bun, if you wants full speed of Bun, avoid using await
in critical path.
As the state of Bun 0.1.3, KingWorld will be slowed down when using await
which might occurs from the following:
await
in handlerschema.body
request.body
The performance will be slowed down by around 1.75x - 3x vary on how powerful the machine is.
KingWorld is an experimental web framework based on bun.
A bleeding edge web framework focused on developer friendliness, and performance, but is not recommended for production.
As KingWorld is in 0.0.0-experimental.x, API is very unstable and will change in any point of time, at-least until 0.1.0 is release.
As bun is currently in early stage of development, some API might changed in the future which might also results KingWorld API to be changed to match the better speed and developer experience.
Author: SaltyAom
Source Code: https://github.com/SaltyAom/kingworld
License: MIT license
1659711524
When developing an enterprise web app, you will probably need to complement it with a spreadsheet table. It is one of the most highly-demanded functions for doing business in digital space. It is not surprising that users, who often have to deal with large amounts of information, love this tool. This instrument helps to cover various aspects of data management that contribute to carefully weighed business decisions.
The internet is full of tips on how to quickly add a basic spreadsheet to a web page, but what if your project requires a mode advanced solution with a wider set of capabilities? Implementing this kind of functionality from scratch can be a tedious and time-consuming task. Therefore, you can consider using commercial JavaScript spreadsheet libraries. They make it much easier to embed a multifunctional Excel-like table into web apps written in pure JavaScript or with popular JS frameworks.
In this article, you have an opportunity to get acquainted with the most noteworthy stand-alone JS spreadsheets and UI widget libraries with this functionality in more detail and choose the right one for your project.
#JavaScript #web-development #spreadsheets
First of all, let us go through JS libraries that are primarily intended to contribute to faster integration of a feature-packed spreadsheet into a web app.
DHTMLX Spreadsheet is a fully customizable JavaScript spreadsheet component with a convenient API for processing tabular data of any complexity. It has an intuitive Excel-like interface adaptable to touch devices. With this library in your dev stack, you get a lot of features for productive working in spreadsheet tables. Besides common grid operations, you can enable users to freeze rows & columns, lock/unlock cells, create drop-down lists with validation, autofill cells with data, apply text-wrapping, sort columns and data ranges, and much more. A user-friendly toolbar (ribbon) with multiple controls will aid users in formatting and styling specific cells.
There is a regularly updated collection of more than 250 built-in functions compatible with Excel and Google Sheets that can be used to manipulate string and numeric data within a cell or range. It is also possible to arrange data in separate worksheets and, when needed, combine data from various sheets into one with the help of cross-referencing via available formulas. DHTMLX Spreadsheet supports a range of predefined number formats with adjustable settings and allows creating custom ones. The spreadsheet interface is also adaptable to various languages. The table navigation is facilitated with a large list of hotkeys. The final version of your document can be converted to Excel format.
All functional benefits of this library are backed up by flexible licensing with affordable prices varying from $599 to $2899. Thus, you can consider DHTMLX Spreadsheet as a product with a good price/quality ratio. Apart from that, you may be interested in reviewing other DHTMLX components for implementing various functionalities required in business apps.
Useful resources: documentation, samples
Free trial version: DHTMLX Spreadsheet
Handsontable is primarily known as a JavaScript grid library for business apps but the decision to include it in this article is not accidental. Although this tool doesn't offer as many text formatting options as Excel, it includes quite a lot of features for manipulating data typical of spreadsheets. The list of the most widely used Handsontable features includes operations on rows & columns (moving, hiding, resizing, freezing), CRUD actions, non-contiguous selection, data validation, export to file, and merging cells. You can also take advantage of more advanced capabilities such as multi-column sorting, data summaries, trimming rows, and nested headers.
With numerous supported cell types such as date, time, dropdown, password, you’ll give users more freedom for working with cell content. To specify the way users will edit data, you can utilize a predefined cell editor or create a custom one. But how does Handsontable address one of the key functions of any business spreadsheet, namely math calculations? To enable users to perform different kinds of calculating operations in your app, you can utilize a separate Formulas plugin based on the HyperFormula calculation engine specifically designed by the Handsontable team. If you have your own ideas on how to make the Handsontable grid tool more effective, you can create custom plugins.
The Handsontable library has a lot of good qualities in terms of functionality that certainly boosts its price. To obtain this tool for web development, you’ll have to fork out from $899 per developer.
Useful resources: documentation, samples
Free trial version: Handsontable
Jspreadsheet PRO (previously known as Jexcel) is an Excel-like spreadsheet plugin notable for its real-time collaboration feature. It offers such essential functionality as text formatting, frozen columns, data filtering, sorting, and searching.
Similar to popular spreadsheet software, Jspreadsheet allows utilizing built-in and custom formulas and performing cross-worksheet calculations. The plugin supports several native editors that can be complemented with custom options to enhance the user experience in data editing. Jspreadsheet lacks some of the common built-in features like keyboard navigation, data validation, and value formatting. However, you can put into action third-party extensions or set up your own add-ons to achieve your goals.
This JavaScript tool is provided in Base and Premium editions via monthly ($39/$119), yearly ($390/$1,190) subscription or one-time purchase (3699$). The premium edition includes extra features, plugins, extensions, priority tech support, and other goodies.
Useful resources: documentation, samples
Free trial version: Jspreadsheet
SpreadJS is a multifaceted Excel-inspired solution designed and maintained by GrapeCity to become a strong response to most of modern data handling demands on the web. When exploring its extensive feature-set, it may be hard for many to immediately name any Excel feature that is not supported by this widget.
First of all, SpreadJS is known for its powerful calculation engine with a large collection of functions of different types for performing complex computations when preparing various business documents. There are many features that will help you to expand users’ abilities in working with cells. For example, you can add cell buttons, barcodes, apply rich text, rotate text in cells, auto merge cells, and much more. To offer a deeper insight into your spreadsheet data, it is possible to add pivot tables, charts, sparklines, tables. An auxiliary desktop design tool named SpreadJS Designer offers a code-free way to quickly create a complex spreadsheet layout or load your existing Excel .xlsx template files and get down to work with data right away.
Everything seems to be great in SpreadJS but there is one important factor that may discourage you to buy this product. It is about high associated expenditures. The thing is that you’ll have to pay not only for a developer license but also for a hostname deployment license. Such a bundle will cost you at least 1499$ per developer. GrapeCity also provides the Wijmo library that can be used in combination with SpreadJS for building a consistent business app much faster.
Useful resources: documentation, samples
Free trial version: SpreadJS
Webix Spreadsheet is a JavaScript UI widget designed to speed up the integration of a multifunctional spreadsheet table into your web project. It is probably one of the most advanced tools included in the Webix UI library. Spreadsheets built with Webix can be equipped with features to which many users have grown accustomed in the desktop Excel. They are built-in math functions, manipulations with rows and columns, sorting and filtering, editing, various types of data, etc.
The widget allows enriching the cell content with sparklines, images, as placeholders. The ability to leave comments in cells will help to avoid any ambiguities. You can also enable such useful functions as cell merging and conditional cells formatting. At times, users may need to focus just on the presented information, that is where the capabilities to hide the headers of rows and columns and greedlines will come in handy. If none of the built-in functions can help you to perform a required operation, it is possible to create a custom one for this purpose. After users finish using the spreadsheet, they export it to PDF/PNG and Excel or activate the printing function to get the hard copy of the table.
If you decide that the Webix Spreadsheet widget is the right tool for your project, then you can consider several licenses with different pricing options floating from $798 to $9,499. Moreover, Webix also offers a pack of UI controls that will be a great addition to the spreadsheet widget.
Useful resources: documentation, samples
Free trial version: Webix Spreadsheet
1659705540
OAuth WebAuth
This plugin offers a WebView implementation approach for OAuth authorization/authentication with identity providers.
Platform | Compatibility |
---|---|
Android | ✅ |
iOS | ✅ |
Web | Work in progress |
Other plugins like Flutter AppAuth uses native implementation of AppAuth which in turn uses SFAuthenticationSession
and CustomTabs
for iOS and Android respectively. When using SFAuthenticationSession
and CustomTabs
your app will/could present some problems like:
With this plugin you will get:
contentLocale
property to ensure the same locale. By default Operating System locale will be used if no contentLocale
is specified.Note:
contentLocale
will apply only if the authentication page supports the specified Locale('...')
and accepts the header: 'Accept-Language': 'es-ES'
OAuthWebView
to BaseWebView
OAuthWebView
renamed onSuccess
function to onSuccessAuth
.As stated before this plugin uses WebView implementation specifically the plugin flutter_inappwebview. For any WebView related problem please check the documentation of that plugin at docs.
Just add the internet permission to your AndroidManifest
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.example">
<uses-permission android:name="android.permission.INTERNET"/>
<application>
...
</application>
Just add this to your Info.plist
<plist version="1.0">
<dict>
....
....
<key>NSAppTransportSecurity</key>
<dict>
<key>NSAllowsArbitraryLoads</key>
<true/>
</dict>
....
....
</dict>
</plist>
OAuthWebView
which handles all the authorization/authentication and navigation logic; this widget can be used in any widget tree of your current app or as an individual authentication screen. For individual authentication screen it offers the widget OAuthWebScreen
which can be started as a new route and also handles the Android back button to navigate backward when applies.BaseWebView
which may be useful for cases in which you need to handle a link to your Auth server, let's say for email confirmation, or password reset, etc. This widget will handle the web UI and automatically get back to you when loaded any of the specified redirectUrls
. The BaseWebView
widget works very similar to OAuthWebView
, it can be used in any widget tree of your current app or as an individual screen. For individual screen it offers the widget BaseWebScreen
which can be started as a new route and also handles the Android back button to navigate backward when applies.This plugin offers two variants to handle these outputs.
Awaiting response from navigator route Future
.
void loginV1() async {
final result = await OAuthWebScreen.start(
context: context,
authorizationEndpointUrl: authorizationEndpointUrl,
tokenEndpointUrl: tokenEndpointUrl,
clientSecret: clientSecret,
clientId: clientId,
redirectUrl: redirectUrl,
baseUrl: baseUrl, //Optional, if you want to get back to the application when the web view gets redirected to baseUrl. This will be like an onCancel callback
scopes: scopes,
promptValues: const ['login'],
loginHint: 'johndoe@mail.com',
onCertificateValidate: (certificate) {
///This is recommended
/// Do certificate validations here
/// If false is returned then a CertificateException() will be thrown
return true;
},
contentLocale: Locale('es'),
refreshBtnVisible: false,
clearCacheBtnVisible: false,
textLocales: {
///Optionally texts can be localized
OAuthWebView.backButtonTooltipKey: 'Ir atrás',
OAuthWebView.forwardButtonTooltipKey: 'Ir adelante',
OAuthWebView.reloadButtonTooltipKey: 'Recargar',
OAuthWebView.clearCacheButtonTooltipKey: 'Limpiar caché',
OAuthWebView.closeButtonTooltipKey: 'Cerrar',
OAuthWebView.clearCacheWarningMessageKey:
'¿Está seguro que desea limpiar la caché?',
});
if (result != null) {
if (result is Credentials) {
authResponse = getPrettyCredentialsJson(result);
} else {
authResponse = result.toString();
}
} else {
authResponse = 'User cancelled authentication';
}
setState(() {});
}
Using callbacks
void loginV2() {
OAuthWebScreen.start(
context: context,
authorizationEndpointUrl: authorizationEndpointUrl,
tokenEndpointUrl: tokenEndpointUrl,
clientSecret: clientSecret,
clientId: clientId,
redirectUrl: redirectUrl,
baseUrl: baseUrl, //Optional, if you want to get back to the application when the web view gets redirected to baseUrl. This will be like an onCancel callback
scopes: scopes,
promptValues: const ['login'],
loginHint: 'johndoe@mail.com',
onCertificateValidate: (certificate) {
///This is recommended
/// Do certificate validations here
/// If false is returned then a CertificateException() will be thrown
return true;
},
contentLocale: Locale('es'),
refreshBtnVisible: false,
clearCacheBtnVisible: false,
textLocales: {
///Optionally text can be localized
OAuthWebView.backButtonTooltipKey: 'Ir atrás',
OAuthWebView.forwardButtonTooltipKey: 'Ir adelante',
OAuthWebView.reloadButtonTooltipKey: 'Recargar',
OAuthWebView.clearCacheButtonTooltipKey: 'Limpiar caché',
OAuthWebView.closeButtonTooltipKey: 'Cerrar',
OAuthWebView.clearCacheWarningMessageKey:
'¿Está seguro que desea limpiar la caché?',
},
onSuccess: (credentials) {
setState(() {
authResponse = getPrettyCredentialsJson(credentials);
});
},
onError: (error) {
setState(() {
authResponse = error.toString();
});
},
onCancel: () {
setState(() {
authResponse = 'User cancelled authentication';
});
});
}
This plugin offers two variants to handle these outputs.
Awaiting response from navigator route Future
.
void baseRedirectV1() async {
final result = await BaseWebScreen.start(
context: context,
initialUrl: initialUrl,
redirectUrls: [redirectUrl, baseUrl],
onCertificateValidate: (certificate) {
///This is recommended
/// Do certificate validations here
/// If false is returned then a CertificateException() will be thrown
return true;
},
textLocales: {
///Optionally texts can be localized
BaseWebView.backButtonTooltipKey: 'Ir atrás',
BaseWebView.forwardButtonTooltipKey: 'Ir adelante',
BaseWebView.reloadButtonTooltipKey: 'Recargar',
BaseWebView.clearCacheButtonTooltipKey: 'Limpiar caché',
BaseWebView.closeButtonTooltipKey: 'Cerrar',
BaseWebView.clearCacheWarningMessageKey:
'¿Está seguro que desea limpiar la caché?',
},
contentLocale: contentLocale,
refreshBtnVisible: false,
clearCacheBtnVisible: false,
);
if (result != null) {
if (result is String) {
/// If result is String it means redirected successful
response = 'User redirected to: $result';
} else {
/// If result is not String then some error occurred
response = result.toString();
}
} else {
/// If no result means user cancelled
response = 'User cancelled';
}
setState(() {});
}
Using callbacks
void baseRedirectV2() {
BaseWebScreen.start(
context: context,
initialUrl: initialUrl,
redirectUrls: [redirectUrl, baseUrl],
onCertificateValidate: (certificate) {
///This is recommended
/// Do certificate validations here
/// If false is returned then a CertificateException() will be thrown
return true;
},
textLocales: {
///Optionally text can be localized
BaseWebView.backButtonTooltipKey: 'Ir atrás',
BaseWebView.forwardButtonTooltipKey: 'Ir adelante',
BaseWebView.reloadButtonTooltipKey: 'Recargar',
BaseWebView.clearCacheButtonTooltipKey: 'Limpiar caché',
BaseWebView.closeButtonTooltipKey: 'Cerrar',
BaseWebView.clearCacheWarningMessageKey:
'¿Está seguro que desea limpiar la caché?',
},
contentLocale: contentLocale,
refreshBtnVisible: false,
clearCacheBtnVisible: false,
onSuccess: () {
setState(() {
response = 'User redirected';
});
},
onError: (error) {
setState(() {
response = error.toString();
});
},
onCancel: () {
setState(() {
response = 'User cancelled';
});
});
}
goBackBtnVisible
, goForwardBtnVisible
, refreshBtnVisible
, clearCacheBtnVisible
, closeBtnVisible
allows you to show/hide buttons from toolbar, if you want to completely hide toolbar, set all buttons to false.urlStream
when you need to asynchronously navigate to a specific url, like when user registered using OauthWebAuth
and the web view waits for user email verification; in this case when the user opens the email verification link you can navigate to this link by emitting the new url to the stream you previously set in the urlStream
instead of creating a new OautHWebAuth
or BaseWebView
.Run this command:
With Flutter:
$ flutter pub add oauth_webauth
This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get
):
dependencies:
oauth_webauth: ^2.2.0+9
Alternatively, your editor might support flutter pub get
. Check the docs for your editor to learn more.
Now in your Dart code, you can use:
import 'package:oauth_webauth/oauth_webauth.dart';
example/lib/main.dart
import 'package:example/src/auth_sample_screen.dart';
import 'package:example/src/base_redirect_sample_screen.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
void main() {
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: const MyHomePage(title: 'Oauth WebAuth samples'),
);
}
}
class MyHomePage extends StatefulWidget {
const MyHomePage({Key? key, required this.title}) : super(key: key);
final String title;
@override
State<MyHomePage> createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.title),
systemOverlayStyle: SystemUiOverlayStyle.dark,
),
body: Center(
child: SingleChildScrollView(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
ElevatedButton(
onPressed: () {
Navigator.push(
context,
MaterialPageRoute(
builder: (context) => const AuthSampleScreen()));
},
child: const Text('Oauth login samples'),
style: ButtonStyle(
backgroundColor: MaterialStateProperty.all(Colors.green)),
),
const SizedBox(height: 4),
ElevatedButton(
onPressed: () {
Navigator.push(
context,
MaterialPageRoute(
builder: (context) =>
const BaseRedirectSampleScreen()));
},
child: const Text('Base redirect samples'),
),
],
),
),
),
);
}
}
Author: luis901101
Source Code: https://github.com/luis901101/oauth_webauth
License: BSD-3-Clause license
1659694917
MultiQoS is a top-class ReactJS Web Development Company in India & USA that provides end-to-end ReactJS Web Development Services to create innovative and dynamic web applications.
We are inclined towards offering robust ReactJS Development Services which consist of all aspects of development, integration, support, and maintenance. Your search for a professional ReactJS Development Company in India ends here.
1659694087
Giving an exceptional User experience is the prime goal of any digital product owner. And what technology can give an as immense and exquisite experience rather than Vue js Development? However, if you consider current trends hiring a Vue.js Developer is giving the global players an edge over their competitors when it comes to quality UI/UX
Services for Upgrading and Maintenance
Hire external Vue JS developers to help your company with cutting-edge technologies that offer all adequate assistance and timely updates.
Advancement of Real-Time Applications
Employ Nmap's VueJS programmers to create real-time processing solutions that will enhance user experience.
Personalized Vue JS application
To customize your mobile and website project, we hire talented and committed VueJS developers from outside.
Integration of a simple app
Hire Vue JS developers to improve your company's understanding by adding new features to your existing applications in a simple manner.
Low-effort optimization
Hire Vue JS developers to provide quick, effective, fit, and finish work that will improve the UI/UX of your project.
Pre-study for Vue.js
The following are just a few fundamental abilities that a Vue.js developer should possess:
Standard basic required Vue.js Knowledge
Get your Vue.js project developed without wasting your time or resources and Hire vue js developer in just 48 hours!
1659677220
WebIO provides a simple abstraction for displaying and interacting with web content. It works with:
This is a non-comprehensive list of projects using WebIO.
Web Artifacts bundle.tar.gz
Build | Coverage | Docs |
---|---|---|
Author: JuliaGizmos
Source Code: https://github.com/JuliaGizmos/WebIO.jl
License: View license
1659669720
TableView.jl is an ag-grid based table viewer built on WebIO.jl. It can display arbitrarily large tables by lazy-loading additional data when scrolling (this is the default for datasets with more than 10k rows).
showtable(yourtable)
returns a WebIO.Scope
which can be displayed with multiple frontends (e.g. IJulia, Blink, Juno...). See the WebIO readme for information on that.
When trying to display big tables (>10k rows) we switch to lazy-loading additional rows while scrolling, which disables the filtering/sorting that's possible for smaller datasets. It's possible (but not trivial) to write proper backend support for those operations -- PRs would be very welcome.
Setting the AG_GRID_LICENSE_KEY
environment variable at build and run time will use the enterprise distribution instead of the normal community distribution.
Author: JuliaComputing
Source Code: https://github.com/JuliaComputing/TableView.jl
License: View license