JavaScript Framework Courses Online

About

WxWidgets formerly known as wxWindows is a framework for developing cross-platform GUI applications in C++. Julian Smart started the framework in 1992 at the Artificial Intelligence Applications Institute, University of Edinburgh. In 1995, a port to Xt was released by Markus Holzem. In May 1997, the Windows and the GTK+ ports were merged and put into a CVS repository.

Content

• Introduction
• What is wxWidgets
• Who should use wxWidgets
• Why use wxWidgets
• Main features

About

Delphi is both an object-oriented programming language (OOP) and an Integrated Development Environment (IDE). Published by the Embarcadero company (formerly CodeGear and more formerly Borland), Delphi is an alternative to languages such as Visual Basic offering development with both rapidity and good quality. It originated from the Pascal language, which then became Object Pascal (pascal with objects support). Delphi is based on the Object Pascal language. The IDE runs on Windows, but the compiler targets Windows, macOS, iOS, Android, and Linux. Third-party add-ins provide the ability to compile to JavaScript for web development. Delphi includes the RunTime Library (RTL) that provides basic functionality across all the platforms. For Windows, it provides the Visual Component Library (VCL), and for cross-platform development, it includes FireMonkey (FMX).

Content

• Introduction
• First application
• Delphi project files
• Reserved keywords
• Statements
• Variables and constants
• Data types
• Boolean expression
• Arithmetic expression
• Flow control
• Pointers
• Objects and classes
• Procedures and functions
• Dynamic-link libraries (DLLs)
• The Debugger
• The GUI - Introduction
• The GUI - Component overview
• The GUI - Multimedia
• Creating own components
• The SysUtils unit
• The Math unit
• Assembler in Delphi

About

Haxe is an open-source high-level cross-platform programming language and compiler that can produce applications and source code, for many different computing platforms from one code-base. It is free and open-source software, released under the MIT License. The compiler, written in OCaml, is released under the GNU General Public License (GPL) version 2.

Haxe includes a set of features and a standard library supported across all platforms, like numeric data types, strings, arrays, maps, binary, reflection, math, HTTP, file system, and common file formats. Haxe also includes platform-specific API's for each compiler target. Kha, OpenFL, and Heaps.io are popular Haxe frameworks that enable creating multi-platform content from one codebase.

Haxe originated with the idea of supporting client-side and server-side programming in one language and simplifying the communication logic between them. Code written in the Haxe language can be compiled into JavaScript, C++, Java, JVM, PHP, C#, Python, Lua, and Node.js. Haxe can also directly compile SWF, HashLink and Neko, bytecode and also runs in interpreted mode.

Haxe supports externs (definition files) that can contain type information of existing libraries to describe target-specific interaction in a type-safe manner, like C++ header files, can describe the structure of existing object files. This enables to use of the values defined in the files as if they were statically typed Haxe entities. Besides externs, other solutions exist to access each platform's native capabilities.

Content

• History
• Compiler
  • Targets
  • Advantages to Haxe
• Language
  • Type system
  • Modules and namespaces
  • Classes
  • Generics
  • Enumerated types
  • Anonymous types
  • Function types
  • Abstract types
  • Structural typing
• Internal architecture
  • Compiler
• Converters to Haxe

About

React-O Hero, A project that brings together those who want to help to those who needs. This is a use case Web and App idea for training Javascript, NodeJS and React.

Technologies used

• Node & Express - Backend javascript code

• Knex - DB Migrations

• React - Frontend

• React Native - Mobile

• Axios - HTTP Client

• Expo - Mobile

• Jest & supertest - Tests

• Celebrate - Validations

• CircleCI - CI

About

Designing a webapp using training resources from Nodejs Developer (HTML5, CSS3, JavaScript, Node.js, APIs, MongoDB). The project is a CRUD of a patient registration application with information on height, weight, percentage of body fat and calculation of body mass index. The back end in node.js follows the Rest pattern in the insert, list, delete, and edit requests as information.

About

NativeScript is an open-source framework to develop mobile apps on the Apple iOS and Android platforms. It was originally conceived and developed by Progress. At the end of 2019 responsibility for the NativeScript project was taken over by long-time Progress partner, nStudio. In December 2020 nStudio also oversaw the induction of NativeScript into OpenJS Foundation as an Incubating Project. NativeScript apps are built using JavaScript, or by using any programming language that transpiles to JavaScript, such as TypeScript. NativeScript supports the Angular and Vue JavaScript frameworks. Mobile applications built with NativeScript result in fully native apps, which use the same APIs as if they were developed in Xcode or Android Studio. Additionally, software developers can re-purpose third-party libraries from CocoaPods, Maven, and npm.js in their mobile applications without the need for wrappers.

Contents

• 1 NativeScript with Angular 4
• 2 Introduction to NativeScript with Angular
  • 2.1 Schematics
  • 2.2 ng add
• 3 Installation and setup of NativeScript
  • 3.1 Basic setup with telerik cli
  • 3.2 Basic setup with telerik cli con't
• 4 Overview of NativeScript and the Application Life Cycle
  • 4.1 Life cycle
    • 4.1.1 Nativescript
• 5 Overview of Property System, Data Binding and Events
• 6 Understanding NativeScript's Multithreading Module
  • 6.1 NS Multithreading con't
• 7 Creating a User Interface with NativeScript
• 8 Designing the Application Logic
  • 8.1 Modularize with @NgModule
    • 8.1.1 High usability - core module
      • 8.1.1.1 Core module con't
    • 8.1.2 Feature Modules
    • 8.1.3 Feature Modules Con't
    • 8.1.4 Model shared for our data
    • 8.1.5 Service APIs
      • 8.1.5.1 Player service
      • 8.1.5.2 Recorder service
      • 8.1.5.3 Logging service
      • 8.1.5.4 Database service
      • 8.1.5.5 Authorization service
    • 8.1.6 Bootstrapping the whole thing
  • 8.2 View with layout
• 9 Schematics exercise
• 10 Using NativeScript Modules
  • 10.1 NS Modules con't
  • 10.2 Accessing media - location, camera, file
• 11 Accessing NativeScript's Animation APIs
• 12 Integrating a NativeScript Application with Native Android and IOS Apps
• 13 Unit Testing and Debugging the Application
  • 13.1 Error handling
  • 13.2 Debugging
  • 13.3 Testing
  • 13.4 Testing con't - unit
  • 13.5 Testing con't - e2e
• 14 Publishing the Application
  • 14.1 Android
• 15 Troubleshooting
• 16 Summary and Conclusion

About

Node.js is an open-source, cross-platform, back-end JavaScript runtime environment that runs on chrome v8 engine and executes JavaScript code outside a web browser. Node.js lets developers use JavaScript to write command line tools and for server-side scripting—running scripts server-side to produce dynamic web page content before the page is sent to the user's web browser. Consequently, Node.js represents a "JavaScript everywhere" paradigm, unifying web-application development around a single programming language, rather than different languages for server-side and client-side scripts.

Node.js allows the creation of Web servers and networking tools using JavaScript and a collection of "modules" that handle various core functionalities. Modules are provided for file system I/O, networking (DNS, HTTP, TCP, TLS/SSL, or UDP), binary data (buffers), cryptography functions, data streams, and other core functions. Node.js's modules use an API designed to reduce the complexity of writing server applications.

Content

• History
• Overview
  • Platform architecture
  • Industry support
• Releases
• Technical details
  • Internals
  • Threading
  • V8
  • Package management
  • Unified API
  • Event loop
  • WebAssembly
  • Native bindings

About

Music Composer

Built with HTML5, CSS and javascript, this website allows basic music playing for ear training and some basic composing

Development Environment

This project was fully written using atom with emmet plugin for fast HTML code typing. The version control was maintained using git.

Compiler

Chrome and edge were used to compile this project. It was also tested to work on iPads using the google chrome developer tools.

Future Work

1. Correcting the Si sound as it is not very accurate.
2. Add a composing note to show the played sounds.
3. Save the music composed on the website.
4. Create user login to save the music composed online.

About

Shopping Cart Discount Code Kata

What is this?

This is a code kata in both C# and JavaScript to be used for developer team training. The code kata are exactly the same in all languages. I use this kata primarly for so called Randori Katas, see more bellow. :)

Shopping cart code kata requirements:

All code should be tested and written with a TDD-approach (test cases first). The system shall allways chose the best possible discount for the customer. If multiple discounts are valid shall the system allways chose the largest discount first and there after the other in descending order.

1. Calculate cart with items price and add a shipping cost of 50SEK.
2. a) Free shipping when total price of all items in cart exceeds 400SEK. b) Free shipping when the cart contains more than 5 different items.
3. If there are 5+ of the same item there should be a volume discount of 10% that's only valid on that specific item.
4. Regular custumers gets 10% discount on the whole cart.
5. Winter holidays sale (Mellandagsrea) 50% on all items in cart between boxing day (26/12) and new years eve. (Can't be combined with 3 or 4)
6. Expired items with a stock balance of less then 10 gives 40% discount. (Can't be combined with 3, 4 or 5)
7. Discount voucher gives customers 15% total cart disount on one purchase. (Can't be combined with 4, 5 or 6)

   Rules of a Randori Session

   • The presenter explains the coding challenge and devides the group into teams of approx. 5 persons
   • The presenter starts the Randori with a pair from audience.
   • The pair will use TDD (Test-Driven Development).
   • Only one in the pair are allowed to touch the keyboard.
   • One half of the pair is changed every 5 minutes. The one coding goes in the audience and the other part of the pair starts coding with a new partner.
   • The pair on the keyboard should continuously explain what they are doing.
   • The audience are not allowed to intervene in the coding, but are allowed to ask the coding pair questions.
   • The pair coding should stop when someone from the audience falls off the sled and only continue when that someone is back on track again.

     Happy coding! :)

     Open source?

     This code kata are created by Stellan Lindell. The code kata source code are completly open source and free to use, both for personal and comercial purposes. Licensed under the MIT Licence.

About

React (also known as React.js or ReactJS) is an open-source, front end, JavaScript library for building user interfaces or UI components. It is maintained by Facebook and a community of individual developers and companies. React can be used as a base in the development of single-page or mobile applications. However, React is only concerned with state management and rendering that state to the DOM, so creating React applications usually requires the use of additional libraries for routing. React Router is an example of such a library.

Content

• Basic usage
• Notable features
  • Components
  • Functional components
  • Class-based components
  • Virtual DOM
  • Lifecycle methods
  • JSX
  • Architecture beyond HTML
  • React hooks
    • Rules of hooks
• Common idioms
  • Use of the Flux architecture

About

JS-Training

Strings

You find here some simple examples and edge cases to learn the js-basics better. Feel free to give feedback for extending this training.

Please fix all problems in the javascript files

Firstly, open your console. In your console, you see all the examples are failing. You are expected to correct all the problems in the folder "js/app.js"

About

JS-Training

Arrays

You find here some simple examples and edge cases to learn the js-basics better. Feel free to give feedback for extending this training.

Please fix all problems in the javascript files

Firstly, open your console. In your console, you see all the examples are failing. You are expected to correct all the problems in the folder "js/app.js"

About

JS-Training

Javascript Arrays Advanced

Find the murderer!

So you have a train travelling through many cities called "Passengers" (in "js/passengers.js"). Every person in this train is somehow related at least to another one. While the train was going through the cities, something is happend: The engineman was murdered! An investigator has been immediately assigned by the local government to find the murderer. The first thing, he does, was having locked all the doors. He does not let the passengers go before the investigation process is finished. The investigator has many questions about the passengers. So you need to help him by writing appropriate functions (in "js/chapters/chapter-xx.js") for finding the murderer. You need to help the investigator in his enquiry. You have to implement (write) the body of the functions below properly. Any error in your function reduces dramatically the health of the investigation. So be carefull with your code, this is very vital because the murderer is still in the train!!!!!

Notes:

About

JS-Training

Arrays

You find here some simple examples and edge cases to learn the js-basics better. Feel free to give feedback for extending this training.

Please fix all problems in the javascript files

Firstly, open your console. In your console, you see all the examples are failing. You are expected to correct all the problems in the folder "js/app.js"

About

ES6 TODO App

This is a simple TODO app written in only core JavaScript in order to teach some of the new concepts in ES6/2015. You are welcome to use this repo any way you like, but note that it is for training purposes only. This code is not production ready.

About

React Slingshot is a comprehensive starter kit for rapid application development using React. Why Slingshot?

1. One command to get started - Type npm start to start development in your default browser.
2. Rapid feedback - Each time you hit save, changes hot reload and linting and automated tests run.
3. One command line to check - All feedback is displayed on a single command line.
4. No more JavaScript fatigue - Slingshot uses the most popular and powerful libraries for working with React.
5. Working example app - The included example app shows how this all works together.
6. Automated production build - Type npm run build to do all this:

About

Javascript, Modularity, and Webpack - A Wizeline Training Course

This is a beginner's frontend course on how javascript handles file structure, modules, and finally webpack. It is designed to take you from very simple development (cerca 1996-2001) to modern development using Webpack.

Motivation

People assume that writing an application for a browser is easy. However, javascript the language was never designed for this, resulting in an ecosystem of tools that have been built to manage that part of the development stack. For example, javascript lacks: Failure is easy, cheap, and common - by design. This makes enterprise application development hard. This course explains the history of this development, why tools like Webpack are needed, and how to use them.

Syllabus

About

Web Platform Developer Training

What is this?

What is the web platform?

What is a web platform developer?

The web platform developer is a developer who can develop a variety of applications for the web platform.

Why would I want to be a web platform developer?

You can build applications for any environment, platform, or device that the web platform supports, including web browsers, all major desktop operating systems, both major mobile phone operating systems, server environments, and even embedded systems. You build these applications using a unified set of technologies that do not change from environment to environment or platform to platform. That means you don't have to learn many languages, always switching contexts and having to learn the nuances of many different languages...HTML, CSS, JavaScript, and the Web APIs are your platform.

About

Software Engineer Internship Training

Developer training program for vintage software.

Stage 1: Clean Code (1 day)

Learn how to write clean, maintainable, extensible code Additional Resources

Stage 2: History of the Web (1 day)

Learn the history of HTML, CSS and JavaScript and what really happens when a browser navigates to a url. Additional Resources

Stage 3: HTML/CSS (3 days)

Learn how to build responsive web pages with HTML and CSS Additional Resources

Stage 4: C# (3 days)

Learn C# Additional Resources

Stage 5: RESTful API (3 days)

Learn how to create a RESTful API with C# Additional Resources

Stage 6: JavaScript (3 days)

Additional Resources

Stage 7: jQuery and the DOM (1 day)

Stage 8: Consuming RESTful Api with Angular 1.x (6 days)

Additional Resources

Stage 9: SQL (3 days)

Additional Resources

Stage 10: Design Patterns (3 days)

Additional Resources

Stage 11: Source Control (1 day)

Stage 12: Unit Testing (1 day)

Advanced Topics

Becoming a Software Craftsman

Advanced JavaScript

Machine Learning

MVC

Ect

About

Hybrid_Cloud_Foundations

Nutanix Hybrid Cloud Training

Chapter 1: Journey to the Modern Hybrid Cloud

1. What the role of a Hybrid Cloud Engineer is
2. The different models to support various Cloud initiatives
3. The Engineers role in Service Level Agreements related to Cloud apps
4. How to choose the optimal Cloud platform for an app, based on business requirements and SLAs

   What does a Hybrid Cloud Engineer do?

   A hybrid cloud engineer can design, create, operate, and manage different types of workloads across multiple clouds and infrastructure providers. The engineer should be able to:

   • Consult and plan with business stakeholders
   • Successfully execute this plan
   • Validate outcomes through their technical skillset The Hybrid Cloud Engineer helps organizations determine their readiness, and make suggestions if an organization isn't ready yet. One of the most important things to check is if business requirements are clearly defined. This is done through Service Level Agreements, or SLAs, need to be completely documented and enforceable. This is what you're going to use to choose the right infrastructure for every service. This is followed by implementation.

     Understanding the Cloud

     NIST defines cloud computing as "a model for enabling ubiquitous, convenient, on-demand network access to a shared pool of configurable computing resources. For instance: networks, servers, storage, applications, and services that can be rapidly provisioned and released with minimal management effort or service provider interaction."

   • With Infrastructure as a Service, or IaaS, you are only managing the workloads and applications that are running on virtual machines and containers.
   • With Platform as a Service, or PaaS, you are only responsible for applications and their data.
   • Finally, with a Software as a Service, or SaaS, model, every aspect of the infrastructure is provided to you. The only thing that you are required to manage is the data. Everything else is being managed by a provider. Starting an organization's digital transformation:
5. How do you leave traditional IT behind and become a Cloud consumer?
6. How do you choose between application hosts? Infrastructure as a Service, Platform as a Service, or Software as a Service?
7. How does your choice impact workload design, deployment, management, and costs?
8. Can you leverage multiple models effectively?

   Application Design: The Monolith

   When we refer to monolithic, we mean there is one, single source of every component in the stack.

   • It is a single application written in a single language.
   • It is run in a batch, or is constantly executed on a single instance of infrastructure.
   • To address performance issues and bottlenecks, it is necessary to scale up by increasing compute, storage, and memory resources. These resources are always constrained to a monolithic servers capabilities.
   • The infrastructure is also monolithic. It is provided by a single vendor, who potentially also controls the application development tools, database, and operating system layers that are running on their hardware.

     Application Design: Distributed Web Scale

     The Internet and open source software lowered application design costs and changed to being distributed over the network. The functionality became a separation of duties from being monolithic. Three-tier web application includes:

   • The web presentation-tier using JavaScript, HTML, and CSS
   • The application logic tier using programming languages such as: Java, C++, Python, or Ruby
   • A database cluster for persistence. Micro-service architecture with further separation of tier function allows application architecture to evolve towards network APIs based on the web, called RESTful APIs, or REST APIs. A customer request comes to a web load balancer. The web load balancer directs the request to any of the web presentation tier members, in this case Web4, to show a web page which needs to display application logic served through the AppServer Load Balancer from the Application Logic Tier members, in this case from AppServer2. AppServer2, in turn, reads data from the database cluster, in this case: the Database3 instance. Examples of these web-scale applications with a global reach are Facebook, Netflix, and Gmail.

     The Cloud Differentiator

     In the State of the DevOps Report 2019, it was determined that the highest performing teams are 24 times more likely to execute on all five cloud capabilities, when compared to lower performing teams. The cloud, therefore, can be viewed as a differentiator for elite performers as well as a tool in general that drives high performance. There are first two major aspects of cloud consumption that organizations need to take into consideration: fiscal consumption and workload predictability.

     Cloud Considerations: Workload Predictability

     The public cloud is best for elastic workloads. The public cloud allows you to spin up or spin down resources to meet the workloads demands quickly, easily, and efficiently when a workload is unpredictable. The private cloud is great for predictable workloads. It is a secure and efficient way to run core workloads, with the agility and sit-back simplicity that IT teams want, and with the control that an organization needs for on-prem workloads. Distributed workloads across public and private cloud still allows you to control and manage them centrally. The overall management of your deployment is simplified this way.

     Organizational Readiness Fundamentals

     Almost every business has a cloud transformation plan. Problems for businesses executing their digital and cloud transformation plans can be caused by their organizational models. Organizational models can refer to how an IT department is structured for example and how technology is actually used. These two models speak to organizational readiness. Organizational readiness refers to how ready a business is to execute their cloud transformation plan successfully. Why do business think about fiscal consumption and their workload predictability? Usually, those conversations begin when a business is considering making the transition to the cloud. One of the most important parts of the process is gathering detailed information and knowing the key stakeholders early on. There are different IT domains to learn as well as what they do to deliver business services.

     What is Cloud Readiness?

   • A low cloud readiness score means that technology and workforce skills are more traditional. This means the current environment is used exclusively to run legacy, shrink-wrapped applications.
   • High cloud readiness means that the technologies and workforce skills that support IT are aligned with what is required to successfully use the full capabilities of the public, private and hybrid cloud. A good example of this scenario is if catalog-based self-service is available to users.

     Cloud Smart, Not Cloud First

     Cloud Smart is about rationalizing applications, infrastructure, skills, and people across hybrid clouds and ensuring everything is where it fits best. You can leverage the essential characteristics of the cloud over various deployment models by looking at the cloud as an experience and a mindset. Since everything is on demand, it doesnt take ten hours or six months to get a cloud result. Rapid elasticity with service measurements allows these organizations to understand how well theyre managing their on-prem and off-prem resources.

     Legacy IT: The Mainframe

     The mainframe is monolithic architecture that first appeared on the computing landscape in the 1940s. There are several reasons for the mainframes continued popularity.

   • The enormous resources and computing power that is provides via its monolithic, converged architecture. It is, for example, 18 times faster than an x86 platform.
   • It also provides decades of uptime and provides high levels of security.
   • It also supports virtualization, which is an increasingly critical element of computing infrastructure today. Despite its many advantages, the mainframe isnt the perfect solution for all computing needs.
   • Having access to the extensive amount of resources a mainframe provides requires a massive capital investment.
   • Mainframes only get more expensive when they need to scale, because their monolithic architectures require massive blocks to expand.
   • Theres also the concern of vendor lock-in, due to the use of proprietary hardware and software.
   • Finally, operating, managing, and maintaining such a complex piece of computing technology requires highly specialized skills.

     Legacy of IT: Distributed Computing

     In the 80s, there was a need for departmental computing, which coincided with advances in memory, storage, software, LAN, and WAN technologies. Advantages

   • The low cost, making the barrier to entry very low. This was a dramatic change from the enormous investments required to stand up a mainframe.
   • By design, these systems were also easier to scale, making it much easier to expand an environment to meet growing needs. Most standards were open and because hardware and software were commoditized, businesses had a wealth of choices when making purchases.
   • Since these were commoditized systems, niche skills were no longer needed to operate and manage them. Disadvantages
   • Underutilization was the norm, which resulted in low return on investment, and high total cost of ownership.
   • Despite being scalable, these systems were not highly available, opening businesses to the risks of downtime and data loss.
   • The inherent scalability of the distributed systems also led to sprawl, which made them difficult to secure and manage.
   • Finally, because of the sheer number of components involved in different systems, IT organizations experienced sprawl as well, becoming disjointed and siloed.

     Legacy IT: Centralized Storage and 3-tier

     Centralized storage, as the name suggests, involves high volume, shareable storage that can be accessed by multiple servers over the network. It provides standalone servers with pools of storage and data protection via multiple network paths, multiple storage processors, and RAID protection at the disk level.

   • A Storage Area Network is a dedicated, specialized, high speed network that provides access to block-level storage. A SAN typically consists of hosts, switches, and storage devices, all connected to each other.
   • A NAS is a storage device that is connected to a network and allows data to be stored and retrieved from a centralized location. NAS devices use Ethernet to access shared storage devices at the file level.
   • Centralized storage works with distributed computing to create the 3-tier infrastructure architecture that is popularly used in datacenters today. In this computing model, servers and storage are separate entities, connected through a storage network. Advantages
   • Centralized storage solved the data availability problem that was caused by distributed computing.
   • The ability to add storage separately from computing resources also meant that companies could scale storage to meet the needs of their growing data.
   • An added benefit was that application high-availability became easier in distributed environments, because centralized storage facilitated shared disk access for clustering. Disadvantages
   • Storage array and network management became a specialized IT domain, resulting in the need for specialized skills.
   • As centralized storage increased in sophistication, it also brought increased complexity via concepts like SAN fabrics, WWPNs, RAID groups,volumes, spindle counts, and so on.
   • The flexibility to add storage separately from computing meant that scaling was also uneven storage was scaled in large blocks, while servers were scaled in smaller increments.
   • This resulted in large CapEX commitments when storage was needed. Since storage was purchased in large blocks, it could sometimes take years to fill the available disk space, resulting in very long time to value.

     Legacy IT: x86 Virtualization

   • Virtualization uses an abstraction layer and resource scheduler called a hypervisor to run virtual machines on shared hardware resources. Virtual machines, or VMs, can be run at 80% or higher resource utilization without contention, solving one of the major problems of distributed and 3-tier architecture.
   • x86 hardware is a good fit for virtualization because, since the mid 2000s, each generation of the x86 processor has added features to improve virtualization performance. The latest generation supports virtualized network, storage, and server infrastructure, with performance that matches dedicated Application Specific Integrated Circuit, or ASIC-based hardware. Advantages
   • The ability to utilize 80% or more of the available infrastructure resources meant that businesses also experienced huge ROI gains with drastically lower TCO.
   • An added benefit was that VMs could be moved between hosts without downtime, and operational processes such as cloning, deployment, backup, and recovery of servers and applications were simplified. Disadvantages
   • VM sprawl and the need for high availability resulted in high demands on storage and network resources.
   • If VM sprawl goes unmanaged, it can result in more complexity and increased costs.
   • Mixed environments which include both virtualized and non-virtualized workloads can result in even more management complexity.

     Legacy IT: Hybrid Cloud Readiness

     If an organization is using a mainframe to:

   • Host a private cloud
   • There is modern application development
   • A supporting DevOps team
   • If it is used for Blockchain, AI, or Big Data integrations Then cloud readiness is high.

About

Barebones React/TypeScript/Express/Sass Boilerplate

This project is a starting point for a TypeScript based React app that also has a local API server using express. There are 2 different Webpack configurations. One for the server and one for the client.

Server

The server build process compiles the TypeScript files found in /src/server into a single bundled JavaScript file located in the /dist directory.

Client

The client build process compiles the React app located in /src/client into a bundled located at /public/js/app.js. The client configuration will also build the Sass files found at /src/client/scss. The App component imports the app.scss file which already includes an import for Bootstrap.

About

javascript-fundamentals

This course contains training classes for JavaScript fundamentals (ES2020). The software engineer can through the examples to understand the concepts as well as the new features of JavaScript. Each section has a README file for more details about that specific feature of the language. Most code example has also its' unit tests to help the student to understand the contract of the feature better as well as hope to make writing unit tests a habit.

Table of Contents

1. Literals & Identifiers
2. Comments
3. Types
4. Operators
5. Conditionals
6. Loops
7. Functions
8. Collections (Arrays, Maps, Sets)
9. Objects
10. Regular Expressions and String Manipulation
11. Classes
12. Modules

About

javascriptComponents-training

This workshop is intended for KNIME developers who would like to learn how to write native JS nodes instead of writing interfaces on the Generic JS View which is more like a Jupyter notebook. These nodes can be written as an extension of org.knime.js.core.javascriptComponents. While this takes a slightly deeper knowledge of KNIME it brings many advantages:

• A big number of ready to be used JS libraries are available already and more are added in each KNIME version.
• The scripts are pure JS and do not contain any KNIME pseudo code for flow variables.
• Scripts can be edited with a fully fledged editor and catch errors before runtime with a linter, etc. During this workshop you will create and deploy a JS node with a simple form asking for first and last names.

  Requirements

  It is advised to bring all the applications needed for development already installed before the workshop.

  Part 1 - Backend

  Part 1 will cover briefly KNIME development with Eclipse and more importantly the backend and project structure.

  Part 2 - Frontend

  Part 2 will cover the JS and CSS frontend and how they are configured and connected to the backend.

About

webpack

Table of Contents

1. Install
2. Introduction
3. Concepts
4. Contributing
5. Support
6. Core Team
7. Sponsoring
8. Premium Partners
9. Other Backers and Sponsors
10. Gold Sponsors
11. Silver Sponsors
12. Bronze Sponsors
13. Backers
14. Special Thanks Install

About

Rails is a web-application framework that includes everything needed to create database-backed web applications according to the pattern. Understanding the MVC pattern is key to understanding Rails. MVC divides your application into three layers: Model, View, and Controller, each with a specific responsibility.

Content

• Getting started

• Model layer

• Controller layer

• View layer

• Frameworks and libraries

About

Immutable collections for JavaScript

application development, no defensive copying, and enabling advanced memoization and change detection techniques with simple logic. [Persistent][] data presents a mutative API which does not update the data in-place, but instead always yields new updated data. Immutable.js provides many Persistent Immutable data structures including: List, Stack, Map, OrderedMap, Set, OrderedSet and Record. These data structures are highly efficient on modern JavaScript VMs by using structural sharing via [hash maps tries][] and [vector tries][] as popularized by Clojure and Scala, minimizing the need to copy or cache data. Immutable.js also provides a lazy Seq, allowing efficient chaining of collection methods like map and filter without creating intermediate representations. Create some Seq with Range and Repeat. Want to hear more? Watch the presentation about Immutable.js:

About

Leaflet is the leading open-source JavaScript library for mobile-friendly interactive maps. Weighing just about 39 KB of gzipped JS plus 4 KB of gzipped CSS code, it has all the mapping [features][] most developers ever need. Leaflet is designed with simplicity, performance and usability in mind. It works efficiently across all major desktop and mobile platforms out of the box, taking advantage of HTML5 and CSS3 on modern browsers while being accessible on older ones too. It can be extended with a huge amount of plugins, has a beautiful, easy to use and well-documented API and a simple, readable source code that is a joy to contribute to. For more info, docs and tutorials, check out the official website. For Leaflet downloads (including the built master version), check out the download page. We're happy to meet new contributors. If you want to get involved with Leaflet development, check out the contribution guide contribute. Let's make the best mapping library that will ever exist, and push the limits of what's possible with online maps!

Content

• Features
  • Elements
  • Support for GIS formats
  • Browser support
• Comparison with other libraries

About

Parser and writer for various spreadsheet formats. Pure-JS cleanroom implementation from official specifications, related documents, and test files. Emphasis on parsing and writing robustness, cross-format feature compatibility with a unified JS representation, and ES3/ES5 browser compatibility back to IE6. This is the community version. We also offer a pro version with performance enhancements, additional features like styling, and dedicated support.

Graph of supported formats (click to show)

Contents

Expand to show Table of Contents

• JS Ecosystem Demos
• Optional Modules
• ECMAScript 5 Compatibility
• Parsing Examples
• Streaming Read
• Parsing and Writing Examples
• Writing Examples
• Streaming Write
• Parsing functions
• Writing functions
• Utilities
• General Structures
• Cell Object
  • Data Types
  • Dates
• Sheet Objects
  • Worksheet Object
  • Chartsheet Object
  • Macrosheet Object
  • Dialogsheet Object
• Workbook Object
  • Workbook File Properties
• Workbook-Level Attributes
  • Defined Names
  • Workbook Views
  • Miscellaneous Workbook Properties
• Document Features
  • Formulae
  • Column Properties
  • Row Properties
  • Number Formats
  • Hyperlinks
  • Cell Comments
  • Sheet Visibility
  • VBA and Macros
• Input Type
• Guessing File Type
• Supported Output Formats
• Output Type
• Array of Arrays Input
• Array of Objects Input
• HTML Table Input
• Formulae Output
• Delimiter-Separated Output
  • UTF-16 Unicode Text
• HTML Output
• JSON
• Excel 2007+ XML (XLSX/XLSM)
• Excel 2.0-95 (BIFF2/BIFF3/BIFF4/BIFF5)
• Excel 97-2004 Binary (BIFF8)
• Excel 2003-2004 (SpreadsheetML)
• Excel 2007+ Binary (XLSB, BIFF12)
• Delimiter-Separated Values (CSV/TXT)
• Other Workbook Formats
  • Lotus 1-2-3 (WKS/WK1/WK2/WK3/WK4/123)
  • Quattro Pro (WQ1/WQ2/WB1/WB2/WB3/QPW)
  • OpenDocument Spreadsheet (ODS/FODS)
  • Uniform Office Spreadsheet (UOS1/2)
• Other Single-Worksheet Formats
  • dBASE and Visual FoxPro (DBF)
  • Symbolic Link (SYLK)
  • Lotus Formatted Text (PRN)
  • Data Interchange Format (DIF)
  • HTML
  • Rich Text Format (RTF)
  • Ethercalc Record Format (ETH)
• Node
• Browser
• Tested Environments
• Test Files
• OSX/Linux
• Windows
• Tests

About

localForage

localForage is a fast and simple storage library for JavaScript. localForage improves the offline experience of your web app by using asynchronous storage (IndexedDB or WebSQL) with a simple, localStorage-like API. localForage uses localStorage in browsers with no IndexedDB or WebSQL support. See [the wiki for detailed compatibility info][supported browsers].

About

RxDB

A realtime Database for JavaScript Applications

RxDB (short for Reactive Database) is a NoSQL-database for JavaScript Applications like Websites, hybrid Apps, Electron-Apps, Progressive Web Apps and NodeJs. Reactive means that you can not only query the current state, but subscribe to all state changes like the result of a query or even a single field of a document. This is great for UI-based realtime applications in way that makes it easy to develop and also has great performance benefits. To replicate data between your clients and server, RxDB provides modules for realtime replication with any CouchDB compliant endpoint and also with custom GraphQL endpoints.

Documentation
 | 
Example-Projects

      alt="follow on Twitter">

Platform-support

RxDB is made so that you can use exactly the same code at We optimized, double-checked and made boilerplates so you can directly start to use RxDB with frameworks like

Quickstart

About

Prezto is the configuration framework for [Zsh][1]; it enriches the command line interface environment with sane defaults, aliases, functions, auto completion, and prompt themes.

Content

• Installation
• Troubleshooting
• Updating
• Usage
• Themes
• Customization

About

virtual-dom

A JavaScript DOM model supporting element creation, diff computation and patch operations for efficient re-rendering

Motivation

Manual DOM manipulation is messy and keeping track of the previous DOM state is hard. A solution to this problem is to write your code as if you were recreating the entire DOM whenever state changes. Of course, if you actually recreated the entire DOM every time your application state changed, your app would be very slow and your input fields would lose focus. virtual-dom is a collection of modules designed to provide a declarative way of representing the DOM for your app. So instead of updating the DOM when your application state changes, you simply create a virtual tree or VTree, which looks like the DOM state that you want. virtual-dom will then figure out how to make the DOM look like this efficiently without recreating all of the DOM nodes. virtual-dom allows you to update a view whenever state changes by creating a full VTree of the view and then patching the DOM efficiently to look exactly as you described it. This results in keeping manual DOM manipulation and previous state tracking out of your application code, promoting clean and maintainable rendering logic for web applications.

Example

var h = require('virtual-dom/h'); var diff = require('virtual-dom/diff'); var patch = require('virtual-dom/patch'); var createElement = require('virtual-dom/create-element'); // 1: Create a function that declares what the DOM should look like function render(count) { return h('div', { style: { textAlign: 'center', lineHeight: (100 + count) + 'px', border: '1px solid red', width: (100 + count) + 'px', height: (100 + count) + 'px' } }, [String(count)]); } // 2: Initialise the document var count = 0; // We need some app data. Here we just store a count. var tree = render(count); // We need an initial tree var rootNode = createElement(tree); // Create an initial root DOM node ... document.body.appendChild(rootNode); // ... and it should be in the document // 3: Wire up the update logic setInterval(function () { count++; var newTree = render(count); var patches = diff(tree, newTree); rootNode = patch(rootNode, patches); tree = newTree; }, 1000);

About

Mousetrap

Mousetrap is a simple library for handling keyboard shortcuts in Javascript. It is licensed under the Apache 2.0 license. It is around 2kb minified and gzipped and 4.5kb minified, has no external dependencies, and has been tested in the following browsers: It has support for keypress, keydown, and keyup events on specific keys, keyboard combinations, or key sequences.

About

Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices. Powerful and easy to use.

Features

About

MathJax

Beautiful math in all browsers

MathJax is an open-source JavaScript display engine for LaTeX, MathML, and AsciiMath notation that works in all modern browsers. It was designed with the goal of consolidating the recent advances in web technologies into a single, definitive, math-on-the-web platform supporting the major browsers and operating systems. It requires no

About

JSON Editor

JSON Editor is a web-based tool to view, edit, format, and validate JSON. It has various modes such as a tree editor, a code editor, and a plain text editor. The editor can be used as a component in your own web application. The library can be loaded as CommonJS module, AMD module, or as a regular javascript file. Supported browsers: Chrome, Firefox, Safari, Opera, Edge, Internet Explorer 11. Cross browser testing for JSONEditor is generously provided by BrowserStack

Features

JSONEditor has various modes, with the following features.

Tree mode

About

Keycloak is an Open Source Identity and Access Management solution for modern Applications and Services. This repository contains the source code for the Keycloak Server, Java adapters and the JavaScript adapter.

Content

• Getting started
• Building from source
• Testing
• Writing Test

About

node-cron

Cron is a tool that allows you to execute something on a schedule. This is typically done using the cron syntax. We allow you to execute a function whenever your scheduled job triggers. We also allow you to execute a job external to the javascript process using child_process. Additionally, this library goes beyond the basic cron syntax and allows you to supply a Date object. This will be used as the trigger for your callback. Cron syntax is still an acceptable CronTime format. Although the Cron patterns supported here extend on the standard Unix format to support seconds digits, leaving it off will default to 0 and match the Unix behavior.

About

Mopidy

Mopidy is an extensible music server written in Python. Mopidy plays music from local disk, Spotify, SoundCloud, Google Play Music, and more. You edit the playlist from any phone, tablet, or computer using a variety of MPD and web clients. Stream music from the cloud Vanilla Mopidy only plays music from files and radio streams. Through extensions, Mopidy can play music from cloud services like Spotify, SoundCloud, and Google Play Music. With Mopidy's extension support, backends for new music sources can be easily added. Mopidy is just a server Mopidy is a Python application that runs in a terminal or in the background on Linux computers or Macs that have network connectivity and audio output. Out of the box, Mopidy is an HTTP server. If you install the Mopidy-MPD extension, it becomes an MPD server too. Many additional frontends for controlling Mopidy are available as extensions. Pick your favorite client You and the people around you can all connect their favorite MPD or web client to the Mopidy server to search for music and manage the playlist together. With a browser or MPD client, which is available for all popular operating systems, you can control the music from any phone, tablet, or computer. Mopidy on Raspberry Pi The Raspberry Pi is an popular device to run Mopidy on, either using Raspbian, Ubuntu, or Arch Linux. Pimoroni recommends Mopidy for use with their Pirate Audio audio gear for Raspberry Pi. Mopidy is also a significant building block in the Pi Musicbox integrated audio jukebox system for Raspberry Pi. Mopidy is hackable Mopidy's extension support and Python, JSON-RPC, and JavaScript APIs make Mopidy a perfect base for your projects. In one hack, a Raspberry Pi was embedded in an old cassette player. The buttons and volume control are wired up with GPIO on the Raspberry Pi, and is used to control playback through a custom Mopidy extension. The cassettes have NFC tags

About

Hypernova

A service for server-side rendering your JavaScript views

Why?

First and foremost, server-side rendering is a better user experience compared to just client-side rendering. The user gets the content faster, the webpage is more accessible when JS fails or is disabled, and search engines have an easier time indexing it. Secondly, it provides a better developer experience. Writing the same markup twice both on the server in your preferred templating library and in JavaScript can be tedious and hard to maintain. Hypernova lets you write all of your view code in a single place without having to sacrifice the users experience.

About

UpUp - Kickstarting the Offline First Revolution

UpUp is a tiny JavaScript library that makes sure your users can always access your site's content, even when they're on a plane, in an elevator, or 20,000 leagues under the sea. Mobile-First has become the de-facto standard for building modern sites. But in a world where everyone is mobile, an always-on connection isn't something we can rely on. It's time to start thinking Offline First. With UpUp you control the content your users see, even when they are offline. And you can do it with just a single JavaScript command.

About

ABP is an open source application framework focused on ASP.NET Core based web application development, but also supports developing other type of applications.

Content

• Getting Started
• UI Framework Options
• Architecture
• Infrastructure
• Application modules

About

Shaka Player is an open-source JavaScript library for adaptive media. It plays adaptive media formats (such as DASH and HLS) in a browser, without using plugins or Flash. Instead, Shaka Player uses the open web standards MediaSource Extensions and Encrypted Media Extensions.

Shaka Player also supports offline storage and playback of media using IndexedDB. Content can be stored on any browser. Storage of licenses depends on browser support.

Our main goal is to make it as easy as possible to stream adaptive bitrate video and audio using modern browser technologies. We try to keep the library light, simple, and free from third-party dependencies. Everything you need to build and deploy is in the sources.

Content

• Platform and Browser
• Dash Features
• HLS Features
• DRM Support
• Media Support and Subtitle Support
• Framework Integration

About

JavaScript Load Image

A JavaScript library to load and transform image files.

Contents

Description

JavaScript Load Image is a library to load images provided as File or Blob objects or via URL. It returns an optionally scaled, cropped or rotated HTML img or canvas element. It also provides methods to parse image metadata to extract images, to overwrite the Exif Orientation value and to restore the complete image header after resizing.

About

quaggaJS

What is QuaggaJS?

QuaggaJS is a barcode-scanner entirely written in JavaScript supporting real- time localization and decoding of various types of barcodes such as EAN, CODE 128, CODE 39, EAN 8, UPC-A, UPC-C, I2of5, 2of5, CODE 93 and CODABAR. The library is also capable of using getUserMedia to get direct access to the user's camera stream. Although the

About

PEG.js is a simple parser generator for JavaScript that produces fast parsers with excellent error reporting. You can use it to process complex data or computer languages and build transformers, interpreters, compilers and other tools easily.

PEG.js is still very much work in progress. There are no compatibility guarantees until version 1.0

public packages

local packages

About

Introduction JsBarcode is a barcode generator written in JavaScript. It supports multiple barcode formats and works in browsers and with Node.js. It has no dependencies when it is used for the web but works with jQuery if you are into that.

About

What is Web Animations? A new JavaScript API for driving animated content on the web. By unifying the animation features of SVG and CSS, Web Animations unlocks features previously only usable declaratively, and exposes powerful, high-performance animation capabilities to developers. What is in this repository? A JavaScript implementation of the Web Animations API that provides Web Animation features in browsers that do not support it natively. The polyfill falls back to the native implementation when one is available. Quick start Here's a simple example of an animation that fades and scales a ``.

Hello world!

var elem = document.querySelector('.pulse');
var animation = elem.animate({
    opacity: [0.5, 1],
    transform: ['scale(0.5)', 'scale(1)'],
}, {
    direction: 'alternate',
    duration: 500,
    iterations: Infinity,
});

About

TweenJS

TweenJS is a simple tweening library for use in Javascript. It was developed to integrate well with the EaselJS library, but is not dependent on or specific to it (though it uses the same Ticker and Event classes by default). It supports tweening of both numeric object properties & CSS style properties.

Example

The API is simple but very powerful, making it easy to create complex tweens by chaining commands. var tween = createjs.Tween.get(myTarget) .to({x:300},400) .set({label:"hello!"}) .wait(500).to({alpha:0,visible:false},1000) .call(onComplete); The example above will create a new tween instance that:

• tweens the target to an x value of 300 over 400ms and sets its label to "hello!"
• waits 500 ms
• tweens the target's alpha to 0 over 1s & sets its visible to false
• calls the onComplete function Tweens are composed of two elements: steps and actions.

About

Surfingkeys is another Chrome/Firefox extension that provides keyboard-based navigation and control of the web in the spirit of the VIM editor. But it's not for VIM users only, it's for anyone who just needs some more shortcuts to his own functions. Surfingkeys is created with all settings described in Javascript, so it's easy for anyone to map any keystrokes to his own defined Javascript function. 

• Sync settings across devices for same account
• Proxy settings
• Markdown preview

About

XRegExp 4.3.0

XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances. XRegExp supports all native ES6 regular expression syntax. It supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module.

Performance

XRegExp compiles to native RegExp objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.

Pannellum

About

Pannellum is a lightweight, free, and open source panorama viewer for the web. Built using HTML5, CSS3, JavaScript, and WebGL, it is plug-in free. It can be deployed easily as a single file, just 21kB gzipped, and then embedded into pages as an ``. A configuration utility is included to generate the required code for embedding. An API is included for more advanced integrations.

About

InstantSearch.js is a JavaScript library for building performant and instant search experiences with Algolia.

InstantSearch.js is a vanilla JavaScript library that lets you create an instant-search result experience using [Algolia][algolia-website]s search API. It is part of the InstantSearch family: InstantSearch.js | [React InstantSearch][react-instantsearch-github] | [Vue InstantSearch][vue-instantsearch-github] | [Angular InstantSearch][instantsearch-angular-github] | [React InstantSearch Native][react-instantsearch-github] | [InstantSearch Android][instantsearch-android-github] | [InstantSearch iOS][instantsearch-ios-github]

Content

• Introduction
• Getting Started
• Installation
• Demos
• Troubleshooting

About

QuoJS Is a micro, modular, Object-Oriented and concise JavaScript Library that simplifies HTML document traversing, event handling, and Ajax interactions for rapid mobile web development. It allows you to write powerful, flexible and cross-browser code with its elegant, well documented and micro coherent API. Designed to change the way that you write JavaScript with the small size goal: a 5-6k gzipped library that handles most basic drudge work with a nice API so you can concentrate on getting stuff done. Released under the Open Source MIT license, which gives you the possibility to use it and modify it in every circumstance. Current JavaScript libraries hate mobile, they are very big libraries that were built based on requirements of desktop devices, so mobile performance isn't optimal. Doesn't have a good support to touch events or a semantic API that would help the developer to create a good & cool JavaScript.

Content

1. Getting Started
2. Browser compatibility
3. GitHub
4. Licensing
5. Touch events
6. How to use
7. Query Methods
8. Element Methods
9. Style Methods
10. DOM Manipulation methods
11. Events handler
12. Gestures Events
13. Swipe methods
14. Pinch methods
15. Rotate methods
16. Ajax Methods
17. Settings in Ajax Requests

About

Scripting Layer for Android (SL4A)

SL4A brings scripting languages to Android by allowing you to edit and execute scripts and interactive interpreters directly on the Android device. These scripts have access to many of the APIs available to full-fledged Android applications, but with a greatly simplified interface that makes it easy to get things done. Scripts can be run interactively in a terminal and in the background. Python, Perl, JRuby, Lua, BeanShell, JavaScript, Tcl, and shell are currently supported, and we're planning to add more. See the [SL4A Video

About

audio.js

audiojs is a drop-in javascript library that allows HTML5's tag to be used anywhere. It uses native where available and falls back to an invisible flash player to emulate it for other browsers. It also serves a consistent html player UI to all browsers which can be styled used standard css. It plays mp3s. No ogg. Because, lets be honest, in the real world, no one really exports ogg files. Sadly, that means Opera and Firefox get flash audio. Hopefully they can add mp3 support soon.

About

The course begins with a brief overview of the AngularJS framework. The overview explains the main AngularJS components - directives, filters, controllers, services, scope. The second section lists and describes the different design and architectural patterns, which are implemented inside the framework. The patterns are grouped by the AngularJS component they are used in. If some patterns are used inside multiple components it will be explicitly mentioned. The last section contains a few architectural patterns, which are commonly used inside most of the single-page applications built with AngularJS.

AngularJS overview

AngularJS is a JavaScript framework developed by Google. It intends to provide a solid base for the development of CRUD Single-Page Applications (SPA). SPA is a web application, which once loaded, does not require full page reload when the user performs any actions with it. This means that all application resources (data, templates, scripts, styles) should be loaded with the initial request or better - the information and resources should be loaded on demand. Since most of the CRUD applications has common characteristics and requirements, AngularJS intends to provide the optimal set of them out-of-the-box. A few important features of AngularJS are: The separation of concerns is achieved by dividing each AngularJS application into separate components, such as: These components can be grouped inside different modules, which helps to achieve a higher level of abstraction and handle complexity. Each of the components encapsulates a specific piece of the application's logic.

Content

• Translations
• Abstract
• Introduction
• AngularJS overview
  • Partials
  • Controllers
  • Scope
  • Directives
  • Filters
  • Services
• AngularJS Patterns
  • Services
  • Singleton
  • Factory Method
  • Decorator
  • Facade
  • Proxy
  • Active Record
  • Intercepting Filters
  • Directives
  • Composite
  • Interpreter
  • Template View
  • Scope
  • Observer
  • Chain of Responsibilities
  • Command
  • Controller
  • Page Controller
  • Others
  • Module Pattern
  • Data Mapper
  • Observer Pattern as an External Service

About

Cookies.js

Cookies.js is a small client-side javascript library that makes managing cookies easy.

Features

Browser Compatibility

The following browsers have passed all of the automated Cookies.js tests:

Getting the Library

Direct downloads

Node Package Manager

npm install cookies-js

Bower

bower install cookies-js

About

Gluegun

Gluegun is a delightful toolkit for building Node-based command-line interfaces (CLIs) in TypeScript or modern JavaScript, with support for: parameters - command-line arguments and options template - generating files from templates patching - manipulating file contents filesystem - moving files and directories around system - executing other command-line scripts http - interacting with API servers prompt - auto-complete prompts print - printing pretty colors and tables semver - working with semantic versioning strings - manipulating strings & template data packageManager - installing NPM packages with Yarn or NPM In addition, gluegun supports expanding your CLI's ecosystem with a robust set of easy-to-write plugins and extensions.

Why use Gluegun?

You might want to use Gluegun if:

• You need to build a CLI app
• You want to have powerful tools at your fingertips
• And you don't want to give up flexibility at the same time If so ... welcome!

  Quick Start

  Just run the gluegun CLI like this:

  spin up your new CLI

  npx gluegun new movies

  choose TypeScript or Modern JavaScript

  now jump into the source

  cd movies

  and link your new executable

  yarn link

  and run it!

  movies help You should see your new CLI help. Open the folder in your favorite editor and start building your CLI!

About

Detect It Easy

Detect It Easy, or abbreviated "DIE" is a program for determining types of files. "DIE" is a cross-platform application, apart from Windows version there are also available versions for Linux and Mac OS. Many programs of the kind (PEID, PE tools) allow to use third-party signatures. Unfortunately, those signatures scan only bytes by the pre-set mask, and it is not possible to specify additional parameters. As the result, false triggering often occur. More complicated algorithms are usually strictly set in the program itself. Hence, to add a new complex detect one needs to recompile the entire project. No one, except the authors themselves, can change the algorithm of a detect. As time passes, such programs lose relevance without the constant support. Detect It Easy has totally open architecture of signatures. You can easily add your own algorithms of detects or modify those that already exist. This is achieved by using scripts. The script language is very similar to JavaScript and any person, who understands the basics of programming, will understand easily

About

oauthd, also known as the 'oauth Daemon' is the open source version of

What is it?

It is a solution based on node.js that enables you to set up and run your own stand-alone, completly free, web Background API Server.

Main features

This server will allows you to authenticate and to integrate the common API providers, with just three lines of JavaScript, completely abstracting away the complexity of OAuth integration. By using the oauth Daemon, you are free to focus your attention on product development instead of losing time on API integration using OAuth.

Exhaustive: compatible with 100+ providers

oauthd works with all your favorite platforms, whether social (Facebook, Twitter, LinkedIn...) or SaaS (Mailchimp, Paypal, Stripe...).

Simplified API calls

With oauthd, you can make API calls instead of dealing with complex OAuth flows. Abstract tokens with the 'Request API' and get user info in a unified way, no matter which provider you are using. The API also lets you perform CRUD actions on behalf of users.

Secured encrypted API

oauthd lets you choose an authorization flow that fits your needs (client-side or server-side). It secures providers API access with SSL encryption and allows you to specify domains/url restrictions for more security.

Integrate in less than 90 seconds

Through the oauthd default administration interface, you can start adding OAuth providers to your app and get a public key to start using these APIs right away.

Modular design

oauthd is highly extendable thanks to a plugin management system based on Git. Each plugin can brings its own layer of features. Anyone can create his own plugin and is free to share it with the Open Source Community. We are eager to see you contribute! Default plugins are furnished to ensure a working minimum environment, with: You can learn more about plugins development

About

Piranha

Feature flags are commonly used to enable gradual rollout or experiment with new features. In a few cases, even after the purpose of the flag is accomplished, the code pertaining to the feature flag is not removed. We refer to such flags as stale flags. The presence of code pertaining to stale flags can have the following drawbacks: Piranha is a tool to automatically refactor code related to stale flags. At a higher level, the input to the tool is the name of the flag and the expected behavior, after specifying a list of APIs related to flags in a properties file. Piranha will use these inputs to automatically refactor the code according to the expected behavior. this course discusses four independent versions of Piranha, one for each of the four supported languages: Java, JavaScript, Objective-C and Swift.

About

DSP.js is a comprehensive digital signal processing library for javascript. It includes many functions for signal analysis and generation, including Oscillators (sine, saw, square, triangle), Window functions (Hann, Hamming, etc), Envelopes (ADSR), IIR Filters (lowpass, highpass, bandpass, notch), FFT and DFT transforms, Delays, Reverb.

Modules

• DFT(bufferSize, sampleRate): Discrete Fourier Transform
  • Usage: var dft = new DFT(1024, 44100); dft.forward(signal); var spectrum = dft.spectrum;
• FFT(bufferSize, sampleRate): Fast Fourier Transform
  • Usage: var fft = new FFT(2048, 44100); fft.forward(signal); var spectrum = fft.spectrum;
• Oscillator(waveform, frequency, amplitude, bufferSize, sampleRate): Signal Generator
  • Sine wave
  • Square wave
  • Saw wave
  • Triangle wave
  • Usage: var osc = new Oscillator(SINEWAVE, 440, 1, 2048, 22050); osc.generate(); var signal = osc.signal;
• ADSR(attack, decay, sustainLevel, sustain, release, sampleRate): Attack-Decay-Sustain-Release Envelope
  • Usage: var envelope = new ADSR(0.01, 0.1, 0.5, 0.1, 0.2, 44100); envelope.process(signal);
• IIRFilter(filter, cutoff, sampleRate): Infinite Impulse Response Filters
  • Low Pass Filter
  • High Pass Filter
  • Usage: var filter = IIRFilter(LOWPASS, 200, 44100); filter.process(signal);
• MultiDelay(maxDelayInSamplesSize, delayInSamples, masterVolume, delayVolume): Delay which feeds back its own delayed signal
  • Usage: var delay = MultiDelay(441005, 441001, 1.0, 0.6); delay.process(signal);
• Reverb(maxDelayInSamplesSize, delayInSamples, masterVolume, mixVolume, delayVolume, dampFrequency): Reverb
  • Usage: var reverb = Reverb(20000, 6500, 0.8, 0.5, 0.9, 4500); reverb.process(signal);

About

Justified Gallery is a JavaScript library that allows you to create an high quality justified gallery of images. This is a common problem for people who create websites: you have a series of images to display, but you are not sure how to arrange them in an elegant way. Important websites such as 500px, Flickr, or Google display images in an excellent way, justifying them similarly to brick wall. Justified Gallery will give you the power to do that too. Justified Gallery is a professional and open source library that even 500px, one of the best photography social network, chose for displaying their images!

Official project page

Release History

3.8.1

• Added maxRowCount parameter
• Added support for SVG images
• .entry-visible renamed to .jg-entry-visible to avoid too generic css classes
• .caption renamed to jg-caption

• Various fixes

  Older versions

  3.7

• Compatible with AMD and CommonJS formats using Universal Module Definition pattern (examples provided for Webpack, Browserify, and AMD/RequireJS)
• $.prop() changed to $.attr() because it was creating problems with Foundation
• The library could now be used without necessarily defining it as jQuery plugin. But it still requires jQuery to provide a better browser compatibility.

  3.6.5

• For more flexibility, option imgSelector to select the image, given an image entry (e.g. a figure or a div)
• $.attr() changed to $.prop() for better compatibility
• Right to left option
• Prevent gallery height collapse when the page is resized and keep the scroll position
• Avoid width check in case the gallery is not visible

  3.6.4

• semplified the possibility to have a gallery of ``.

  3.6.3

• Added in thumbnailPath an extra parameter which specify the current image. In this way properties of that image could be read
• Fixed bugs for filter when used specifying a function
• Fixed bugs for filter when norewind is used
• Performance improvements in case of norewind
• Changed the selector behaviour. Only direct children of the gallery can be choose as gallery entry.
• Fixed bug for maxRowHeight

  3.6.2

• cssAnimation = true as default. Its time to move to the future and leave IE in the past.
• fixed cssAnimation
• scrollbar existence check to avoid image resizing flickering
• The boxes could now be configured to have a background color to be visible with waitThumbnailsLoad = false.
• removed the fixedHeight option since now this behaviour can be replicated using maxRowHeight.
• The last row height will be calculated as the average row height of all the other rows. Before the last row height was always following the rowHeight option, that could be smaller than the effective height of all the other rows. For example: a gallery of images of 100x100px in a container of 950px, where rowHeight = 100. That gallery would contain 9 pictures for each row, and the extra space used for justification. Each row will have approximately an height of 105px after the justification. In this example the last row height would be 105px, where in the past it would usually be 100px if not justified.
• other bugfixes

  3.6.1

• bugfixes
• lastRow option can be 'nojustify', which is the same as 'left', or it can be 'justify', 'center', 'right' or 'hide'.
• refreshSensitivity option, to configure the change in width allowed (in px) without re-building the gallery
• thumbnailPath to configure JG with a custom thumbnail selector, e.g. we want to do select the correct thumbnail changing only a suffix of the current filename $("#myGallery").justifiedGallery({ thumbnailPath: function (currentPath, width, height) { if (Math.max(width, height) < 250) { return currentPath.replace(/(.)(_[a-z]+)(..)/, "$1small$2"); } else { return currentPath.replace(/(.*)([a-z]+)(..*)/, "$1_medium$2"); } } });

  3.6

• Sort (works also with infinite scroll)
• Filter (works also with infinite scroll)
• Randomize images now works also with infinite scroll
• Text entries (i.e. without images) support
• Destroy method
• maxRowHeight could be also a percentage
• configurable sizeRangeSuffixes. e.g. to have only thumbnails and big images it could be: sizeRangeSuffixes : { 500: '_t', 2000: '_m' }
• Configurable entry selector
• Code refactoring

3.5.4

• Added the border option

• Fixed some problems with waitThumbnailsLoad and infinite scroll

  3.5

• The default suffixes are all empty, to be simpler to understand. To have the previous suffixes, the following settings can be used: sizeRangeSuffixes : { 'lt100': '_t', 'lt240': '_m', 'lt320': '_n', 'lt500': '', 'lt640': '_z', 'lt1024': '_b' }

• Now is possible to have entries with the structure:

  ...

• Fixed margins

• The border of the entire gallery can be customized

• Corrected bugs for the callbacks when waitThumbnailsLoad = false

  3.4

• Performance improvements

  • In presence of width and height attributes in thumbnails, and with the option 'waitThumbnailsLoad', the layout is immediately built, and the thumbnails will appear randomly while they are loaded.
  • Other code refactorings to be more performant

• With nojustify, if there is only a row, it doesn't justify anything. The previous behaviour seems too like a bug than a feature.

• Infinite scroll example with plain javascript to be more understandable.

• Fixes some bugs with infinite scroll

  3.3

• No more crops

  • Removed some floating point approximations that caused some small crops

• Initial opacity settings for the caption to allow them to be always visible

  • Can be also configured changing the less file, if one prefers CSS animations

• All caption settings in a single object to be more compact captionSettings : { //ignored with css animations animationDuration : 500, visibleOpacity : 0.7, nonVisibleOpacity : 0.0 },

• Justification formulas refactoring to be more maintainable

  3.2

• A gallery of div can be used instead of a

• Fixed errors for the last rows

• Option to use only css animations (i.e cssAnimation)

• Without css animations

  • Configurable caption fadein/fadeout time (i.e. captionsAnimationDuration)
  • Configurable caption final opacity (i.e. captionsVisibleOpacity)
  • Configurable images fadein time (i.e. imagesAnimationDuration)

• Configurable treshold that decides to justify the row also in presence of nojustify (i.e. justifyThreshold)

  3.1

• Improved the algorithm to reduce the image crops

• Fixed errors with some jQuery versions

• Fixed errors with fixed height

• Settings checks and parsing

• Added event jg.rowflush

  3.0

• Totally rewritten!

• Row by row loading

  • The plugin doesn't wait that all the gallery thumbnails are loaded
  • A row is printed when the its thumbnails are available
  • Non-blocking layout creation

• No more white spaces (If the gallery needs to load a bigger image, it first show the smaller and then replace it with the bigger)

• Improved the algorithm for a better result

  • No more white pixels at the end of a row (bugfix)
  • Reduced a lot the image crops
    • Vertical centering
    • Proportional images enlargement looking the image aspect ratio

• Improved the algorithm efficiency

  • No more extra tags or new elements added to create the layout
  • All the images remain in the DOM, they aren't deleted or created
    • Hence, each tag remains in the links and in the images

• Added maxRowHeight option

• Custom captions

• Thumbnails randomization (randomize option)

• Statefulness

  • can be called again changing only some settings
  • can be called again to update the layout (after add or remove of images)

• Infinite scroll capable

• Improved last row behavior

  • Last row option changed
    • justifyLastRow setting has been renamed to lastRow, and it accepts: 'justify', 'nojustify', 'hide'.
  • Option to hide the row if it is incomplete and cannot be justified
  • The plugin can justify also with lastRow = 'nojustify', if the free space is small.

• Silent error handling

  • If a thumbnail doesn't exists, it is ignored in the layout (hided)
  • If the plugin needs an inexistent thumbnail, it maintains the previous one
  • Errors are still visible in the console

• Loading spinner

  • Visible when a new row needs to be loaded
  • Pure CSS spinner
  • Configurable changing the CSS/Less

• Project structure

  • Grunt to manage the build
  • Less
  • Tests
  • Javascript and CSS validation
  • CSS filename changed to be more standard

• License changed to MIT

• Improved the gallery size check to be less invasive

• Fixed lightbox removal when the page is resized

  2.1

• Setting removed: 'usedSizeRange', now the plugin do it automatically

• Setting behavior changed: 'extension', now it accept a regular expression. The old behavior still works, but is not safe.

• New behavior: if an image defines the attribute data-safe-src, this is choice, no matter what the src attribute is. This can be used to avoid the problems with Photon or other services that resize the images, changing the image srcs.

  2.0

• Setting removed: 'lightbox', now can be done simply with the onComplete callback.

• Added Setting: 'rel' to change all the links rel attribute.

• Added Setting: 'target' to change all the links target attribute.

• Setting name changed: 'complete' to 'onComplete'.

• Setting name changed: 'sizeSuffixes' to 'sizeRangeSuffixes'.

• Setting name changed: 'usedSuffix' to 'usedSizeRange'.

• Added the CSS for the div that shows the Justified Gallery errors. Now can be changed, or hided.

About

chessboard.js

chessboard.js is a JavaScript chessboard component. It depends on [jQuery]. Please see [chessboardjs.com] for documentation and examples.

What is chessboard.js?

chessboard.js is a JavaScript chessboard component with a flexible "just a board" API that chessboard.js is a standalone JavaScript Chess Board. It is designed to be "just a board" and expose a powerful API so that it can be used in different ways. Here's a non-exhaustive list of things you can do with chessboard.js: move. search and playback games (see [Example 5000]) chessboard.js board. chessboard.js is flexible enough to handle any of these situations with relative ease.

What can chessboard.js not do?

The scope of chessboard.js is limited to "just a board." This is intentional and makes chessboard.js flexible for handling a multitude of chess-related problems. This is a common source of confusion for new users. [remove?] Specifically, chessboard.js does not understand anything about how the game of chess is played: how a knight moves, whose turn is it, is White in check?, etc. Fortunately, the powerful [chess.js] library deals with exactly this sort of problem domain and plays nicely with chessboard.js's flexible API. Some examples of chessboard.js combined with chess.js: [Example 5000], [Example 5001], [Example 5002] Please see the powerful [chess.js] library for an API to deal with these sorts of questions. This logic is distinct from the logic of the board. Please see the powerful Here is a list of things that chessboard.js is not: chessboard.js is designed to work well with any of those things, but the idea behind chessboard.js is that the logic that controls the board should be independent of those other problems.

Docs and Examples

Developer Tools

create a build in the build/ directory

npm run build

re-build the website

npm run website

About

PHP PhantomJS

PHP PhantomJS is a flexible PHP library to load pages through the PhantomJS headless browser and return the page response. It is handy for testing websites that demand javascript support and also supports screen captures. Feature List

• Load webpages through the PhantomJS headless browser
• View detailed response data including page content, headers, status code etc.
• Handle redirects
• View javascript console errors
• View detailed PhantomJS debug information
• Save screen captures to local disk
• Output web pages to PDF document
• Set viewport size
• Set fixed header and footer for PDF output
• Define screen capture x, y, width and height parameters
• Delay page rendering for a specified time
• Delay page rendering until page resources are fully loaded
• Execute PhantomJS with command line options
• Easily build and run custom PhantomJS scripts

About

WadJS

A Javascript library for manipulating audio. It's like jQuery for your ears.

Table of Contents

1. Installation
2. Introduction
3. Panning
4. Filters
5. Microphone Input
6. Configuring Reverb
7. Audio Sprites
8. Logging
9. Sound Iterator
10. Tuna Effects
11. Audio Listener
12. Play Labels
13. External Fx
14. Presets
15. Polywads
16. Compression
17. Audio Meter
18. Pitch Detection
19. MIDI Input
20. Access to the Audio Context
21. Cross-browser Compatibility
22. Acknowledgements
23. How to Contribute
24. API Documentation

About

JSX-Control-Statements is a Babel plugin that extends JSX to add basic control statements: conditionals and loops. It does so by transforming component-like control statements to their JavaScript counterparts - e.g. Hello World! becomes condition() ? 'Hello World!' : null. Developers coming to React from using JavaScript templating libraries like Handlebars are often surprised that there's no built-in looping or conditional syntax. This is by design - JSX by is not a templating library, it's declarative syntactic sugar over functional JavaScript expressions. JSX Control Statements follows the same principle - it provides a component-like syntax that keeps your render functions neat and readable, but desugars into clean, readable JavaScript. The only dependency JSX-Control-Statements relies upon is Babel. It is compatible with React and React Native. :skull_and_crossbones: Beware: This is a Babel plugin. It changes your code to other code - this means that some tooling that looks at your code (e.g. static analysis, typescript) is likely to not work. This plugin dates back to when JSX was daring and Javascript was more like playdough than meccano - if you want to stay on the well-trodden path stick with writing && and map.

Table of Contents

• A Note on Transformation and Alternative Solutions
• Installation
• Syntax
  • If Tag
    • <If>
    • <Else ></Else> (deprecated)
    • Transformation
  • Choose Tag
    • <Choose>
    • <When>
    • <Otherwise>
    • Transformation
  • For Tag
    • Transformation
  • With Tag
    • Transformation
• Linting
  • ESLint
  • FlowType
• Alternative Solutions
  • Pure JavaScript
    • Conditionals
    • Loops
    • Comparison
  • React Components
• What about Typescript
• Major Versions

About

Finance.js

Introduction Finance.js makes it easy to incorporate common financial calculations into your application. The library is built on pure JavaScript without any dependencies. This project is hosted on GitHub. You can report bugs and discuss features on the GitHub issues page. Finance.js is available for use under the MIT software license. Getting Started npm install financejs --save or

About

jsforce

Salesforce API Library for JavaScript applications (both on web browser and Node.js)

Overview

JSforce (f.k.a. Node-Salesforce) is an isomorphic JavaScript Library utilizing Salesforce's API: It works both in the browser and with Node.js. It capsulates the access to various APIs provided by Salesforce in asynchronous JavaScript function calls. It also has command line interface (CLI) which gives interactive console (REPL), so you can learn the usage without hassle.

About

SlickNav v1.0.10

Responsive Mobile Menu jQuery Plugin

Features

• Multi-level menu support
• Flexible, simple markup
• Cross-browser compatibility
• Keyboard Accessible
• Degrades gracefully without JavaScript
• Creates ARIA compliant menu
• • *

About

SVGeezy

A JavaScript plugin to handle your images in browsers that don't support SVGs

SVGeezy is in essence, a fallback plugin. It allows you to use SVGs for all your assets, giving you complete resolution independence. It checks if the browser supports SVGs, if not, changes the src of the image to a .png instead (or whatever you pass in).

About

JsAction

JsAction is a tiny event delegation library that allows decoupling the DOM nodes on which the action occurs from the JavaScript code that handles the action. The traditional way of adding an event handler is to obtain a reference to the node and add the event handler to it. JsAction allows us to map between events and names of handlers for these events via a custom HTML attribute called jsaction. Separately, JavaScript code registers event handlers with given names which need not be exposed globally. When an event occurs the name of the action is mapped to the corresponding handler which is executed. Finally, JsAction uncouples event handling from actual implementations. Thus one may late load the implementations, while the app is always able to respond to

About

An Ember CLI addon that allows you to render and serve Ember.js apps on the server. Using FastBoot, you can serve rendered HTML to browsers and other clients without requiring them to download JavaScript assets. Currently, the set of Ember applications supported is extremely limited. 

Content

• Introduction and features
• Installation and Configuration
• App Server Configuration
• Using Node/NPM dependencies
• FastBoot services
  • Cookies
  • Header
  • Host
  • Query Parameter
  • Path
  • Protocol
• Shoebox
• Rehydration
• Know the limitations

About

SpookFlare

SpookFlare has a different perspective to bypass security measures and it gives you the opportunity to bypass the endpoint countermeasures at the client-side detection and network-side detection. SpookFlare is a loader/dropper generator for Meterpreter, Empire, Koadic etc. SpookFlare has obfuscation, encoding, run-time code compilation and character substitution features. So you can bypass the countermeasures of the target systems like a boss until they "learn" the technique and behavior of SpookFlare payloads.

• Obfuscation
• Encoding
• Run-time Code Compiling
• Character Substitution
• Patched Meterpreter Stage Support
• Blocked powershell.exe Bypass

  / _| \/ \ / | |/ / | | /\ | \ | _ \ / () | () | ' list ID | Payload | Description
  1 | meterpreter/binary | .EXE Meterpreter Reverse HTTP and HTTPS loader
  2 | meterpreter/powershell | PowerShell based Meterpreter Reverse HTTP and HTTPS loader 3 | javascript/hta | .HTA loader with .HTML extension for specific command
  4 | vba/macro | Office Macro loader for specific command

About

Filterrific

Filterrific is a Rails Engine plugin that makes it easy to filter, search, and sort your ActiveRecord lists:

Features

• Makes heavy use of ActiveRecord Scopes
• ActionController helpers to shuttle filter params from ActionView forms to ActiveRecord based models, and to return matching records back from ActiveRecord to ActionView.
• Form helpers to build powerful search and filter forms with ease.
• Javascript assets to auto-submit filter form on change via AJAX.
• Image asset to show a spinner in the Filterrific form when new records are being loaded via AJAX.
• API option to use Filterrific with Rails API mode. Just use gem 'filterrific', require: 'filterrific_api' in your Gemfile.

  ---

  ---

About

RingoJS

Ringo is a JavaScript platform built on the JVM and optimized for server-side applications. It's based on the Mozilla Rhino JavaScript engine. It adds a number of features to Rhino that make it suitable for real-world, large-scale application development:

• A fast, auto-reloading, and CommonJS-compliant module loader.
• A rich set of modules covering I/O, logging, development tools and much more.
• Support for blocking and non-blocking I/O.
• Scalable HTTP server based on the Jetty project.
• Support for CommonJS packages to install or write additional software components. For more information, visit the RingoJS web site:

About

Graph Dracula - a JavaScript Graph Library

Graph Dracula is a set of tools to display and layout interactive graphs, along with various related algorithms. Based on JavaScript and SVG. The code is released under the MIT license, so commercial use is not a problem. Creating a graph is simple! You can also customise anything easily.

1. install the dependencies: npm install --save graphdracula raphael or jspm install npm:graphdracula
2. create an html file with a tag having the ID paper.
3. require graphdracula (via browserify or webpack): var Dracula = require('graphdracula') var Graph = Dracula.Graph var Renderer = Dracula.Renderer.Raphael var Layout = Dracula.Layout.Spring var graph = new Graph() graph.addEdge('Banana', 'Apple') graph.addEdge('Apple', 'Kiwi') graph.addEdge('Apple', 'Dragonfruit') graph.addEdge('Dragonfruit', 'Banana') graph.addEdge('Kiwi', 'Banana') var layout = new Layout(graph) var renderer = new Renderer('#paper', graph, 400, 300) renderer.draw()

About

Jailed flexible JS sandbox

Jailed is a small JavaScript library for running untrusted code in a sandbox. The library is written in vanilla-js and has no dependencies. With Jailed you can: The untrusted code may then interract with the main application by directly calling those functions, but the application owner decides which functions to export, and therefore what will be allowed for the untrusted code to perform. The code is executed as a plugin, a special instance running as a restricted subprocess (in Node.js), or in a web-worker inside a sandboxed frame (in case of web-browser environment). The iframe is created locally, so that you don't need to host it on a separate (sub)domain. You can use Jailed to: need to create a sandboxed worker / subprocess manually; and web-browser, the code works unchanged; execute user-submitted code; 3rd-party code and provide it the precise set of functions to harmlessly operate on the part of your application;

(or in the opposite direction), and let those functions be invoked from the other site (without a need for manual messaging) thus

About

TileStream TileStream is a high-performance map tile server powered by [MBTiles][1]. It's like TileCache, TileStache, and other map servers in that it serves normal image files that can be used in OpenLayers, Google Maps, Modest Maps, and other Javascript APIs without much trouble - and with lots of enhancements when you

About

PinchZoom is a Javascript library providing multi-touch gestures for zooming and dragging on any DOM element.

Content

• Installation
• Usage
• Requirements
• Options
• Methods
• Examples
• Events
• Released versions
• Troubleshooting

About

jade4j - a jade implementation written in Java

jade4j's intention is to be able to process jade templates in Java without the need of a JavaScript environment, while being fully compatible with the original jade syntax.

Contents

Example

index.jade doctype html html head title= pageName body ol#books for book in books if book.available li #{book.name} for #{book.price} Java model List books = new ArrayList(); books.add(new Book("The Hitchhiker's Guide to the Galaxy", 5.70, true)); books.add(new Book("Life, the Universe and Everything", 5.60, false)); books.add(new Book("The Restaurant at the End of the Universe", 5.40, true)); Map model = new HashMap(); model.put("books", books); model.put("pageName", "My Bookshelf");

About

meyda

Meyda is a Javascript audio feature extraction library. Meyda supports both offline feature extraction as well as real-time feature extraction using the [Web Audio API][web-audio-api]. We wrote a paper about it, which is available [here][meyda-paper]. Want to ask questions, or chat about Meyda? Check out our [slack channel] on the Web Audio Slack Team. You'll need to [sign up here][web-audio-slack-team-signup] before you can join.

About

About

JavaScript often abbreviated as JS, is a programming language that conforms to the ECMAScript specification. JavaScript is high-level, often just-in-time compiled, and multi-paradigm. It has curly-bracket syntax, dynamic typing, prototype-based object-orientation, and first-class functions.

Alongside HTML and CSS, JavaScript is one of the core technologies of the World Wide Web. JavaScript enables interactive web pages and is an essential part of web applications. The vast majority of websites use it for client-side page behavior, and all major web browsers have a dedicated JavaScript engine to execute it.

As a multi-paradigm language, JavaScript supports event-driven, functional, and imperative programming styles. It has application programming interfaces (APIs) for working with text, dates, regular expressions, standard data structures, and the Document Object Model (DOM).

The ECMAScript standard does not include any input/output (I/O), such as networking, storage, or graphics facilities. In practice, the web browser or other runtime system provides JavaScript APIs for I/O.

JavaScript engines were originally used only in web browsers, but they are now core components of other runtime systems, such as Node.js and Deno. These systems are used to build servers and are also integrated into frameworks, such as Electron and Cordova, for creating a variety of applications.

Content

• History
• Website client-side usage
  • Examples of scripted behavior
  • Libraries and frameworks
• Other usages
• Features
  • Imperative and structured
  • Weakly typed
  • Dynamic
  • Object-orientation (prototype-based)
  • Functional
  • Delegative
  • Miscellaneous
  • Vendor-specific extensions
• Syntax
  • Simple examples
  • More advanced example
• Security
  • Cross-site vulnerabilities
  • Misplaced trust in the client
  • Misplaced trust in developers
  • Browser and plugin coding errors
  • Sandbox implementation errors
  • Hardware vulnerabilities
• Development tools
• Related technologies
  • Java
  • JSON
  • WebAssembly
  • Transpilers

About

D3.js (also known as D3, short for Data-Driven Documents) is a JavaScript library for producing dynamic, interactive data visualizations in web browsers. It makes use of Scalable Vector Graphics (SVG), HTML5, and Cascading Style Sheets (CSS) standards. It is the successor to the earlier Protovis framework. Its development was noted in 2011, as version 2.0.0 was released in August 2011.

Content

• Context
• Technical principles
  • Selections
  • Transitions
  • Data-binding
  • Appending nodes using data
• API structure
  • Maths
  • Arrays
  • Geometry
  • Color

About

Fluent.js is a JavaScript implementation of Project Fluent, a localization framework designed to unleash the expressive power of the natural language. Project Fluent keeps simple things simple and makes complex things possible. The syntax used for describing translations is easy to read and understand. At the same time it allows, when necessary, to represent complex concepts from natural languages like gender, plurals, conjugations, and others. Packages Fluent.js consists of a set of packages which have different use-cases and can be installed independently of each other. 

Content

• Packages
• Learn the FTL Syntax

About

JavaScript Enhancements is a plugin for Sublime Text 3.

A little introduction to this plugin could be found in this css-tricks.com article: Turn Sublime Text 3 into a JavaScript IDE This plugin uses Flow (javascript static type checker from Facebook) under the hood. This is in BETA version for testing. It offers better JavaScript autocomplete and also a lot of features about creating, developing and managing JavaScript projects, such as: You could use it also in existing projects (see the Wiki)! It turns Sublime Text into a JavaScript IDE like! This project is based on my other Sublime Text plugin JavaScript Completions Note: If you want use this plugin, you may want uninstall/disable the JavaScript Completions plugin, if installed.

Content

• OS Supported
• Dependencies
• Installation
• Usage
• Overview
• Support

About

Jayson is a [JSON-RPC 2.0][jsonrpc-spec] and [1.0][jsonrpc1-spec] compliant server and client written in JavaScript for [node.js][node.js] that aims to be as simple as possible to use.

Table of contents

Features

• Servers that can listen to several interfaces at the same time
• Supports both HTTP and TCP client and server connections
• Server-side method routing
• Relaying of requests to other servers
• JSON reviving and replacing for transparent serialization of complex objects
• CLI client
• Promises
• Fully tested to comply with the [official JSON-RPC 2.0 specification][jsonrpc-spec]
• Also supports [JSON-RPC 1.0][jsonrpc1-spec]

  Example

  A basic JSON-RPC 2.0 server via HTTP: Server example in examples/simple_example/server.js: 'use strict'; const jayson = require('./../..'); // create a server const server = jayson.server({ add: function(args, callback) { callback(null, args[0] + args[1]); } }); server.http().listen(3000); Client example in examples/simple_example/client.js invoking add on the above server: 'use strict'; const jayson = require('./../..'); // create a client const client = jayson.client.http({ port: 3000 }); // invoke "add" client.request('add', [1, 1], function(err, response) { if(err) throw err; console.log(response.result); // 2 });

About

About

Jurassic is an implementation of the ECMAScript language and runtime. It aims to provide the best performing and most standards-compliant implementation of JavaScript for .NET. Jurassic is not intended for end-users; instead it is intended to be integrated into .NET programs. If you are the author of a .NET program, you can use Jurassic to compile and execute JavaScript code.

Features

• Supports all ECMAScript 3 and ECMAScript 5 functionality, including ES5 strict mode
• Well tested - passes over five thousand unit tests (with over thirty thousand asserts)
• Simple yet powerful API
• Compiles JavaScript into .NET bytecode (CIL); not an interpreter
• Deployed as a single .NET assembly (no native code)
• Basic support for integrated debugging within Visual Studio
• Uses light-weight code generation, so generated code is fully garbage collected
• Tested on .NET 3.5, .NET 4 and Silverlight

About

jQuery is a JavaScript library designed to simplify HTML DOM tree traversal and manipulation, as well as event handling, CSS animation, and Ajax. It is free, open-source software using the permissive MIT License. As of May 2019, jQuery is used by 73% of the 10 million most popular websites. Web analysis indicates that it is the most widely deployed JavaScript library by a large margin, having at least 3 to 4 times more usage than any other JavaScript library.

jQuery's syntax is designed to make it easier to navigate a document, select DOM elements, create animations, handle events, and develop Ajax applications. jQuery also provides capabilities for developers to create plug-ins on top of the JavaScript library. This enables developers to create abstractions for low-level interaction and animation, advanced effects, and high-level, themeable widgets. The modular approach to the jQuery library allows the creation of powerful dynamic web pages and Web applications.

Content

• Overview
• Features
  • Browser support
• Distribution
• Interface
  • Functions
    • Query methods
    • Static utilities
  • No-conflict mode
  • Typical start-point
  • Chaining
  • Creating new DOM elements
  • Ajax
• jQuery plug-ins

About

gulp is an open-source JavaScript toolkit created by Eric Schoffstall used as a streaming build system (similar to a more package-focussed Make) in front-end web development.

It is a task runner built on Node.js and npm, used for automation of time-consuming and repetitive tasks involved in web development like minification, concatenation, cache busting, unit testing, linting, optimization, etc.

gulp uses a code-over-configuration approach to define its tasks and relies on its small, single-purpose plugins to carry them out. The gulp ecosystem includes more than 3500 such plugins.

Content

• Overview
• Need for a task runner
• Operation
• Anatomy of gulpfile
  • Plugins
  • Tasks
  • Default task
• Example tasks
  • Image Task
  • Scripts Task
  • Watch Task

About

SproutCore is an open-source JavaScript web framework. Its goal is to allow developers to create web applications with advanced capabilities and a user experience comparable to that of desktop applications. When developing a SproutCore application, all code is written in JavaScript. A notable fork of SproutCore is Ember.js. Both projects are maintained separately and have taken different directions.

Content

• Introduction
• Features and capabilities
• Roadmap

About

Meteor, or MeteorJS, is a free and open-source isomorphic JavaScript web framework written using Node.js. Meteor allows for rapid prototyping and produces cross-platform (Android, iOS, Web) code. It integrates with MongoDB and uses the Distributed Data Protocol and a publish–subscribe pattern to automatically propagate data changes to clients without requiring the developer to write any synchronization code. On the client, Meteor can be used with any popular front-end JS framework, Vue, React, Svelte, Angular, or Blaze.

Content

• History
• Distributed Data Protocol
• Packages and Tools

About

Ember.js is an open-source JavaScript web framework, utilizing a component-service pattern. It allows developers to create scalable single-page web applications by incorporating common idioms, best practices, and patterns from other single-page-app ecosystem patterns into the framework.

Content

• Philosophy and design
• Basic concepts
• Ember software stack
  • Ember CLI
  • Ember Data
  • Ember Inspector
  • Fastboot
  • Liquid Fire
• Release process
  • Release cycle
  • Upgrading and backward compatibility

About

React (also known as React.js or ReactJS) is an open-source, front-end, JavaScript library for building user interfaces or UI components. It is maintained by Facebook and a community of individual developers and companies. React can be used as a base in the development of single-page or mobile applications. However, React is only concerned with state management and rendering that state to the DOM, so creating React applications usually requires the use of additional libraries for routing, and fully-fledged form solutions. React Router and Formik are examples of such libraries respectively.

Content

• Basic usage
• Notable features
  • Components
  • Functional components
  • Class-based components
  • Virtual DOM
  • Lifecycle methods
  • JSX
  • Architecture beyond HTML
  • React hooks
    • Rules of hooks
• Common idioms
  • Use of the Flux architecture