Smart Mask – Máscara de Dados

Precisando de uma máscara de CPF, CNPJ ou entre outras?

Smart Mask (https://github.com/pkunzel/smart_mask) é uma biblioteca de máscara de dados bem simples com o intuito de fornecer múltiplas mascaras que com frequencia com frequência em um sistema ou app. O Projeto é constituído por duas classes, uma que aplica as máscaras e outra que monitora elementos HTML para manter a máscara aplicada. 

Como funcionam as classes? 

ApplyMask 

A Classe apply mask possui apenas métodos estáticos que estão prontos para serem chamados mediante passagem de parâmetros conforme exemplo abaixo 

ApplyMask.toCPF('88888888888') 
// output '888.888.888-88' 

ApplyMask.toPhone('51999999998') 
// output '(51) 999999998'

ApplyMask.charactersOnly('qwerty12345') 
// output 'qwerty' 

CustomMask

Gera eventos para os elementos com o atributos data-custom-mask=”mascara”, onde máscara é o nome do tipo de máscara a ser implementada. As opções são 

• cpf: um CPF 

• cnpj: um CNPJ 

• phone: um telefone com DDD incluso 

• cep: um CEP 

• date: uma data seguindo o formato DD/MM/YYYY 

• numbers: extrai apenas os valores numéricos 

• characters: extrai apenas os caracteres 

• non-special-characters: Extrai apenas os caracteres não especiais 

Exemplo 

HTML 

<input type="text" data-custom-mask="cpf" value="11122233344" /> 

JS 

// Ao iniciar a página 

window.addEventListener('load', (e) => new CustomMask()); 

// Obs.: Pode ser feito inicializado em qualquer outro momento. 

Importante: Qualquer valore que seja maior que o tamanho da máscara terá os últimos caracteres removidos. ou seja, um CPF que venha com 15 caracteres devido a algum erro terá os últimos 4 caracteres removidos.

Nova versão – MOBX 6

O MobX é uma biblioteca responsável por gerenciamento de estado simples e escalável. Aplica este gerenciamento e escalonamento de forma transparente a programação reativa funcional.

O MobX já possui 5 anos. Já foi adotado por empresas como Microsoft(Outlook), Netflix, Amazon e E.A. Games (Battlefield). Ele possui a mesma filosofia desde o início. Se algo pode ser derivado pelo estado do aplicativo, será derivado automaticamente.

Em contraste a isso, o ecossistema JavaScript mudou significativamente ao longo dos anos. No entanto, propostas do JavaScript como observables, Object.observe e decorators nunca foram materializados. O MobX 6 é uma versão que não traz muitos novos recursos, mas sim uma consolidação em consideração ao estado atual do JavaScript.

Adeus Decorators!

Usar decorators não é mais regra no MobX. Quando começou, o MobX era um projeto do TypeScript e utilizava decorators. Atualmente, as implementações experimentais do decorator são incompatíveis com a proposta de campos de classe que logo será padronizada. As implementações de decorator legado (Babel) e experimental (TypeScript) não serão capazes de interceptar inicializações de campos de classe. Mas como ficará o MobX depois dos decorators?

Em vez de usar decorator nos membros durante a definição de classe, os membros da instância precisam  ser anotados no construtor, usando o utilitário makeObservable.

import {observable, computed, action, makeObservable} from "mobx"

// Antes:
class TodoStore {
    @observable
    todos: Todo[] = []

    @computed
    get unfinishedTodoCount() {
        return this.todos.filter(todo => !todo.done).length
    }

    @action
    addTodo(todo: Todo) {
        this.todos.push(todo)
    }
}

// Depois:
class TodoStore {
    todos: Todo[] = []

    constructor() {
        makeObservable(this, {
            todos: observable,
            unfinishedTodoCount: computed,
            addTodo: action
        })
    }

    get unfinishedTodoCount() {
        return this.todos.filter(todo => !todo.done).length
    }

    addTodo(todo: Todo) {
        this.todos.push(todo)
    }
}

O makeObservable não requer configurações de compilação sofisticadas. Migrar uma base de código que use diversos decorators para makeObservable pode ser um desafio. O MobX vem com um mod de código para fazer isso automaticamente. Utilizando o comando:

npm mobx-undecorate

Utilizando este comando, todos os decorators da pasta de origem serão reescritos automaticamente! Depois, atualize sua configuração TypeScript/Babel e estará tudo pronto para prosseguir.

Documentação nova!

Com a retirada da norma de utilização de decorators, a documentação foi revisada e reestruturada, sendo mais curta, com menor repetição e discutindo melhor os cenários comuns.

Suporte a navegador aprimorado

O MobX 6 suporta mais mecanismos JavaScript que o MobX 5. O 5 exigia suporte de proxy, tornando-o inadequado para Internet Explorer e React Native, por isso, o Mobx 4 era mantido ativamente. No entanto, o MobX 6 substitui os dois. Ele ainda exigirá Proxies, mas será possível cancelar o uso do Proxy caso precise oferecer suporte a mecanismos mais antigos.

Você pode verificar mais novidades em:

Gostou desta notícia? Comente abaixo!

Referência: https://michel.codes/blogs/mobx6

Angular vs ReactJS: Qual o Framework Front-End mais requisitado de 2020

Olá pessoal, o primeiro semestre de 2020 foi uma época cheia de mudanças. Ainda assim, permanece a eterna batalha entre Angular e React. Antes de iniciar a comparação, esclareceremos alguns pontos sobre ambas as tecnologias:

Angular:

Desenvolvido pelo Google e lançado pela primeira vez em 2010, é um framework de desenvolvimento front-end com uma boa estrutura, um ecossistema próprio, regras rígidas e um estilo de código declarativo. Possui uma profunda curva de aprendizado, bastante difícil, mas depois de possuir todas as possibilidades do Angular, ele auxiliará a criação do seu projeto.

Baseado na arquitetura MVC (Model-View-Controller), fornece aos desenvolvedores as peças fundamentais que são necessárias para projetar aplicativos móveis e da web.

React

React foi criado em 2011 e foi criado pelo Facebook. É uma biblioteca front-end que oferece uma oportunidade de construir uma excelente UI. Fácil de ler, escrever e integrar com outras estruturas JavaScript. Com React, você não utiliza somente a lógica do desenvolvedor, mas também a imaginação. Possuindo um ambiente de desenvolvimento flexível, amplia os horizontes de pensamento do desenvolvedor.

Oportunidades

Angular:

Desenvolvido para facilitar a criação de aplicativos nativos e híbridos ricos em recursos, como um SPA ou MPA.

React:

Tem por objetivo expandir as interfaces de usuário complexas, principalmente em apps web e móveis para Android e iOS.

Template Language

Angular:

Utilizando TypeScript, é adequado para desenvolvimento de apps complicados e você não queira perder seu tempo detectando bugs, pois o TypeScript ajuda a detectá-los mais cedo.

React:

Escrito em JavaScript, pode ser utilizado com diversos tipos de aplicações devido ao suporte e integração em outras linguagens.

Performance

Angular:

Funcionando de maneira mais devagar que o React, mas ainda com velocidade satisfatória, o Angular inclui todas as etapas, desde a criação de um projeto até a otimização de código.

React:

Rápido devido à forma como foi concebido, adiciona eficiência e simplicidade ao desenvolvimento de apps.

E qual escolher para ser um desenvolvedor sob demanda?

Escolha o Angular quando precisar:

  • Desenvolver aplicativos ricos em recursos;
  • Estrutura confiável e estável;
  • Desenvolver um app em tempo real, com base em bate-papo ou mensagens;
  • Aplicativos nativos, híbridos ou web que deveriam ser projetos de investimento substanciais;
  • Código em TypeScript;
  • Programação orientada a objetos.

Escolha o Angular quando precisar:

  • Desenvolver app’s modernos e leves a nível empresarial em um curto espaço de tempo;
  • Estrutura flexível, fornecendo soluções seguras de desenvolvimento de sites;
  • Aplicativos de plataforma cruzada ou SPA;
  • Expander a funcionalidade do aplicativo existente;
  • Forte apoio da comunidade.

Tendências:

De acordo com o NPM Trends, o React é mais popular em 2020:

Tendências NPM

O StackOverflow Trends oferece uma visão diferente da situação. De 2014 a 2019, o React e Angular tiveram quase a mesma popularidade, mas o React se tornou um líder nesta corrida:

Tendências de estouro de pilha

Conclusão:

Levando em consideração as estatísticas, o React é a estrutura mais demandada em 2020. Mesmo assim, escolha o seu framework ou biblioteca de acordo com sua necessidade de trabalho e experiência.

Gostou deste artigo? Comente abaixo!

Referências: https://techstory.in/angular-vs-reactjs/

Introdução ao Puppeteer, uma biblioteca NodeJS

O Puppeteer é uma biblioteca que fornece uma API de alto nível para controlar o Chrome ou o Chromium através do Protocolo DevTools.

A maioria das coisas que você pode realizar manualmente pelo navegador pode ser feita usando o Puppeteer. Como por exemplo:

  • Gerar Screenshots e PDF’s de páginas;

  • Rastrear um SPA (Single-Page Application) e gerar conteúdo pré renderizado;

  • Automatizar o envio de formulários, testes de interface do usuário, entrada de teclado etc;

  • Criar ambiente de testes automatizado e atualizado;

  • Executar os testes diretamente na versão mais recente do Chrome usando os recursos mais recentes de JavaScript;

  • Capturar um rastreamento da linha do tempo do seu site para ajudar no diagnóstico de problemas de desempenho;

  • Testar as extensões do Chrome.

Instalação

Para utilizar o Puppeteer no seu projeto, execute:

npm i puppeteer
# ou “yarn add puppeteer”

Quando você instala o Puppeteer, ele baixa uma versão recente do Chromium.

O Puppeteer será familiar para as pessoas que usam outros frameworks de teste do navegador. Você cria uma instância do Navegador, abre páginas e as manipula com a API do Puppeteer.

Crie seu arquivo e o salve como example.js.

Tirar ScreenShot:

Neste exemplo, navegaremos até a página https://example.com e salvaremos uma captura de tela como example.png:

const puppeteer = require('puppeteer');
(async () => {
    const browser = await puppeteer.launch();
    const page = await browser.newPage();
    // Navega até a pagina destino
    await page.goto('https://example.com');
    // Tira um Screenshot da página
    await page.screenshot({path: 'example.png'});
    await browser.close();
})();

Execute o script na linha de comando:

node example.js

Criando um PDF:

Podemos utilizar o Puppeteer para criar um PDF da página, adicionando o seu formato de folha:

Salve o seu arquivo como criarPdf.js

const puppeteer = require ('puppeteer');

(async () => {
    const browser = await puppeteer.launch();
    const page = await browser.newPage();
    // Especifica qual a página a ser transformada em PDF
    await page.goto('https://example.com', {waitUntil:'networkidle2'});
    // Salva o arquivo em PDF
    await page.pdf({path: 'criarPdf.pdf', format: 'A4'});
    await browser.close();
})();

Execute o comando:

node criarPdf.js

Descobrindo dimensões da viewport do site:

Você pode descobrir as dimensões da viewport de um site, capturando o width e height da viewport do site especificado.

Salve seu arquivo como getDimensions.js

const puppeteer = require('puppeteer');

(async ()=> {
    const browser = await puppeteer.launch();
    const page = await browser.newPage();
    await page.goto('https://example.com');

    // Obtendo o viewport da página
    const dimensions = await page.evaluate(() => {
        return {
            // Retorna o width da viewport
            width: document.documentElement.clientWidth,
            // Retorna o height da viewport
            height: document.documentElement.clientHeight,
            deviceScaleFactor: window.devicePixelRatio
        };
    });

    console.log('Dimensions:', dimensions);
    await browser.close();
})();

Execute o comando:

node getDimensions.js

E esta será a sua resposta. Um objeto com os valores de largura, altura e fator de escala do dispositivo.

Gostou deste artigo? Comente abaixo!

Mapa de Calor com AmCharts

Neste tutorial simples e rápido estarei mostrando como criar um gráfico de mapa de calor (heat map) com a biblioteca AmCharts.

Então vamos começar. Primeiro você precisará criar um arquivo HTML com as seguintes tags.

<html>
<head>
  <!-- Setar para utf-8 para evitar problemas nos caracteres especiais -->
  <meta charset="utf-8"/>
</head>
<body>

  <!-- Buscando bibliotecas direto do site da AmCharts -->
  <script src="https://www.amcharts.com/lib/4/core.js"></script>
  <script src="https://www.amcharts.com/lib/4/maps.js"></script>
  <script src="https://www.amcharts.com/lib/4/geodata/brazilLow.js"></script>

  <!-- Onde nosso gráfico será criado -->
  <div id="chartdiv"></div>
</body>
</html>

A explicação já esta inclusa nos comentários, mas resumidamente precisamos do utf-8 para não dar problema com estados que possuem acento no nome. As bibliotecas são chamadas do site para não precisar baixar nada.

Agora você pode criar uma tag script no final do HTML e colocar o código inline ou apontar para um arquivo JS externo. A escolha é sua.

Feito isso, precisaremos de uma fonte de dados. Para o nosso exemplo e de referência futura, você pode usar a lista abaixo. E ja peço desculpas pelo tamanho da lista, mas não quis minificar para ser fácil de entender.

let dados = [
  {
    "id" : "BR-AC",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-AL",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-AP",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-AM",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-BA",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-CE",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-DF",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-ES",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-GO",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MA",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MT",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MS",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MG",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PA",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PB",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PR",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PE",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PI",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RJ",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RN",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RS",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RO",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RR",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-SC",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-SP",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-SE",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-TO",
    "value" : Math.floor(Math.random()*10000)
  }
];

Como você pode ver, a lista precisa de um ID com a abreviação BR-UF. Porque não apenas o UF? Porque deus quis assim…. kkkk… Eles provavelmente fazem uma separação de paises pois esta biblioteca permite criar mapas de qualquer pais do mundo. A segunda parte pode ser um número qualquer fixo, mas para nosso exemplo eu quis fazer com que fossem valores aleatórios até 10000.

Feito isso, adicione o código abaixo. É importante ler os cometários para entender o que e por que está acontecendo.

// Define o local e tipo de gráfico
let chart = am4core.create("chartdiv", am4maps.MapChart);


// Atribui o 'brazilLow' como o mapa
// Você pode optar pelo 'brazilHigh', basta alterar aqui e src do script no html
// Também define que as partes que montam o mapa serão com base no MapPolygonSeries
chart.geodata = am4geodata_brazilLow;
let polygonSeries = chart.series.push(new am4maps.MapPolygonSeries());
polygonSeries.data = dados;
polygonSeries.useGeodata = true;


// Preenche os dados para fazer o mapa de calor
// Faremos com que os menores valores sejam verdes e maiores sejam vermelhos
polygonSeries.heatRules.push({
  property: "fill",
  target: polygonSeries.mapPolygons.template,
  min: am4core.color("green"),
  max: am4core.color("red")
});


// Define as legendas, posição e cores.
let heatLegend = chart.createChild(am4maps.HeatLegend);
heatLegend.series = polygonSeries;
heatLegend.align = "right";
heatLegend.width = am4core.percent(25);
heatLegend.marginRight = am4core.percent(4);
heatLegend.minValue = 0;
heatLegend.maxValue = 10000;
heatLegend.valign = "bottom";


// Configuras os tooltips (texto ao passar o mouse)
let polygonTemplate = polygonSeries.mapPolygons.template;
polygonTemplate.tooltipText = "{name}: {value}";
polygonTemplate.nonScalingStroke = true;
polygonTemplate.strokeWidth = 0.5;


// Muda a cor do estado ao passar o mouse
let hs = polygonTemplate.states.create("hover");
hs.properties.fill = am4core.color("green").brighten(-0.5);

Isso ai, com isso você terá um mapa mais ou menos (pois muda a cada atualização) assim:

Conheça Drop.js, uma biblioteca JavaScript

Drop.js é uma biblioteca JavaScript e CSS para criação de menus dropdowns e outros pop-ups. A biblioteca utiliza o Tether.js para posicionar seus elementos com eficiência.

Conheça alguns recursos:

Como o Drop é construído em cima do Tether.js, você consegue usufruir dos benefícios de posicionamento eficientemente.

  • Drops podem ser alinhados dentro de outros drops;
  • O Drop usa acelração da GPU para se manter em 60fps ao utilizar o scrolling;
  • Você pode utilizar toda a potência do Tether para posicionar o seu Drop em qualquer lugar;
  • Eles podem ser configurados para abrir quando o usuário clica, passa o mouse ou focaliza um elemento;
  • Os Drops são reposicionados automaticamente quando o usuário utiliza o scroll na tela, reorientando para permanecer na exibição;
  • O Drop é mantido pelos desenvolvedores do HubSpot que se preocupam em fazer tudo o que você precisa.

Inicialização:

Para criar um Drop, crie uma instância drop:

let dropInstance = new Drop({
  target: document.querySelector('.drop-target'),
  content: 'Welcome to the future',
  classes: 'drop-theme-arrows',
  position: 'bottom left',
  openOn: 'click'
})

Métodos:

Você pode chamar alguns métodos na sua instância drop:

open()

Abre o drop. Adiciona o drop-open e outras classes ao drop;

close()

Fecha o drop. Remove o drop-open e outras classes do drop. Drops fechados ainda permanecem no DOM;

remove()

Remove o drop do DOM. Pode ser usado como uma alternativa para o close();

toggle()

Fecha o drop se estiver aberto, e abre o drop se estiver fechado;

isOpened()

Retorna true se o drop estiver aberto;

position()

Reposiciona o drop. Utilize-o se você alterar o conteúdo do drop ou a posição do elemento;

destroy()

Remove o drop junto com todos os seus eventos.

Continue lendo “Conheça Drop.js, uma biblioteca JavaScript”

Phaser.js #1 – Intro

Nesta série de artigos iremos abordar o desenvolvimento de jogos utilizando o Phaser.js, uma ferramenta para criação de jogos JavaScript. Abordaremos um ambiente para que você crie seus jogos. Nisto, se inclui a execução de um servidor Web local e obtenção da versão mais recente do Phaser.

Por que utilizar um servidor web local?

Quando você solicita algo na web, você usa o protocolo http, que garante que você acesse apenas os arquivos aos quais está destinado. Se você utiliza o file:// para arquivos locais, não há segurança a nível de servidor.

O seu jogo precisará carregar alguns recursos, como imagens, arquivos de áudio, JSON e alguns arquivos JavaScript. Ele precisa ter a segurança necessária para ficar livre de possíveis ataques. Por isso utilizaremos o servidor web, que disponibiliza o http://

Recomendo o uso do XAMPP, que possui uma configuração fácil.

Qual editor de código usar?

Realmente, fica a seu critério. Utilize o seu editor de texto favorito. Particularmente, eu prefiro o Visual Studio Code.

Fazendo o download do Phaser:

Você pode fazer o download diretamente da página de downloads.

npm:
npm install phaser@3.21.0
cdn:
<script src="//cdn.jsdelivr.net/npm/phaser@3.21.0/dist/phaser.js"></script>
<script src="//cdn.jsdelivr.net/npm/phaser@3.21.0/dist/phaser.min.js"></script>

Instalados o servidor, editor de texto e baixado o Phaser? Então vamos começar!

Criando um Olá Mundo!

Chegou a hora de criarmos algo e verificarmos se tudo está funcionando perfeitamente. Certifique-se de descobrir o webroot do seu servidor e crie um arquivo index.html dentro dele. Insira o seguinte código:

<! DOCTYPE html>
<html>
<head>
    <script src = "https://cdn.jsdelivr.net/npm/phaser@3.15.1/dist/phaser-arcade-physics.min.js"> </script>
</head>
<body>

    <script>
    var config = {
        tipo: Phaser.AUTO,
        largura: 800,
        altura: 600,
        física: {
            padrão: 'arcade',
            videogames: {
                gravidade: {y: 200}
            }
        }
        cena: {
            preload: preload,
            criar: criar
        }
    };

    var game = novo Phaser.Game (config);

    função preload ()
    {
        this.load.setBaseURL ('http://labs.phaser.io');

        this.load.image ('céu', 'ativos / céu / espaço3.png');
        this.load.image ('logo', 'assets / sprites / phaser3-logo.png');
        this.load.image ('vermelho', 'ativos / partículas / red.png');
    }

    função create ()
    {
        this.add.image (400, 300, 'céu');

        partículas de var = this.add.particles ('red');

        var emissor = particulas.createEmitter ({
            velocidade: 100,
            escala: {início: 1, final: 0},
            blendMode: 'ADD'
        });

        var logo = this.physics.add.image (400, 100, 'logo');

        logo.setVelocity (100, 200);
        logo.setBounce (1, 1);
        logo.setCollideWorldBounds (true);

        emitter.startFollow (logo);
    }
    </script>

</body>
</html>

Inicialize o seu servidor, e acesse o endereço 127.0.0.1/index.html.

Você deve ver uma saída parecida com isso:

Detalhe: é uma animação xD

Se ocorreu algum erro, ou a animação não está sendo visualizada, abra as suas opções de desenvolvedor do navegador e verifique o que o console está logando.

Onde consigo mais exemplos?

Você pode verificar os exemplos em Phaser aqui. Você encontrará um editor de código ativo, para modificar o código e executá-lo em tempo real para ver as alterações imediatamente.

Você também pode fazer o download de todos os exemplos no repositório do github. Você encontrará todos os recursos para uso em seus próprios jogos.

Você pode ler o artigo original em inglês neste link: https://phaser.io/tutorials/getting-started-phaser3/index

Gostou deste artigo? Fique atento à sequência que logo será lançada 😀

Conheça a CryptoCoinJS, uma biblioteca JavaScript para Criptomoedas.

CryptoCoinJS é um projeto JavaScript que ajuda você a interagir com diversas criptomoedas existentes na atualidade, como o famoso Bitcoin, Litecoin, Dogecoin, entre muitas outras. A maioria dos módulos é totalmente compatível com o seu navegador e com o Node.js. Naturalmente, os módulos que fazem interface diretamente com os nós de pares não serão executados no navegador.

Princípios da biblioteca:

Acreditando na filosofia Node.js e UNIX – a idéia de criar pequenos componentes que fazem uma coisa e fazem bem. Escrever software dessa maneira permite que os indivíduos usem e contribuam com muito mais eficácia do que escrevendo uma biblioteca monolítica. O CryptoCoinJS acredita que as pessoas são mais importantes que o código e, portanto, é fundamental escrever um código que seja fácil de ler, fácil de documentar cada módulo com a API e exemplos, e esse código é o inimigo 1 2.

Escrever testes é uma das melhores maneiras de comunicar expectativas entre desenvolvedores. Se a documentação é uma maneira de se comunicar para o consumidor do seu módulo, os testes são uma maneira de se comunicar entre os desenvolvedores.

Plataformas:

O CryptoCoinJS está focado no Node.js e no navegador usando o Browserify. Não há suporte a navegadores herdados, ou seja, se o seu navegador não suporta ECMAScript 5 (2009 – 2010) e não suporta window.crypto.getRandomValues​​(), alguns dos módulos podem não funcionar.

Começando:

O CryptoCoinJS é escrito em JavaScript puro e pode ser usado no servidor (Node.js) e no cliente (navegador moderno> 2010).

A primeira e provavelmente a mais óbvia é que você precisará de um editor de texto. Sublime Text , Github Atom ou Vim farão uma boa escolha.

O Node.js é executado no Windows, Mac OS X ou Linux. É muito fácil de instalar, basta acessar nodejs.org/download e executar o instalador para sua plataforma de escolha. O Node.js agrupa o npm que, estranhamente, não representa o Node.j Package Manager, apesar de ser seu único objetivo.

Continue lendo “Conheça a CryptoCoinJS, uma biblioteca JavaScript para Criptomoedas.”

QUnit.js: um framework para testes de unidade JavaScript.

Você sabe o que é o QUnit?

O QUnit é um framework para testes de unidade JavaScript poderoso e fácil de usar. É utilizado para testes em projetos jQuery, jQuery UI e jQuery Mobile e é capaz de testar qualquer código JavaScript genérico.

O QUnit foi originalmente desenvolvido por John Resig como parte do jQuery. Em 2008, ele recebeu sua própria home page, nome e documentação da API, permitindo que outras pessoas a utilizem para os testes. Anteriormente, o QUnit ainda dependia de jQuery, mas em 2009 isto foi corrigido, e agora o QUnit é executado de forma completamente autônoma. Os métodos de asserção do QUnit seguem a especificação CommonJS Unit Testing, que foi até certo ponto influenciada pelo QUnit.

Como começar?

Uma configuração mínima para um teste do QUnit:

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>QUnit Example</title>
  <link rel="stylesheet" href="https://code.jquery.com/qunit/qunit-2.9.2.css">
</head>
<body>
  <div id="qunit"></div>
  <div id="qunit-fixture"></div>
  <script src="https://code.jquery.com/qunit/qunit-2.9.2.js"></script>
  <script src="tests.js"></script>
</body>
</html>

E o conteúdo do tests.js:

QUnit.test( "hello test", function( assert ) {
  assert.ok( 1 == "1", "Passed!" );
});

No node:

Instale o QUnit globalmente para poder usar o CLI:

$ npm install -g qunit

Crie arquivos de teste em um test directory e execute:

$ qunit

Você deve ver algo como:

TAP version 13
ok 1 Module > Test #1
ok 2 Module > Test #2
1..2
# pass 2
# skip 0
# todo 0
# fail 0

E é isso! Enquanto o QUnit procura por arquivos de teste “test”, você também pode coloca-los em qualquer lugar e, em seguida, especificar caminhos de arquivo ou expressões glob:

$ qunit 'tests/*-test.js'

Para ver as opções adicionais suportadas, basta executar:

$ qunit --help

No npm:

npm install --save-dev qunit

Para testar os recursos mais recentes e correções de bugs no QUnit, uma versão gerada automaticamente a partir do último commit para o repositório QUnit Git também está disponível para uso:

Para mais informações sobre o framework, acesse o site principal do QUnit no link: qunitjs.com/

Gostou deste artigo? Comente abaixo!

Conheça o Phaser.JS, uma biblioteca de criação de jogos JavaScript

Você conhece a biblioteca Phaser.JS para criação de jogos em JavaScript?

Phaser é uma biblioteca para criação de jogos que foi idealizada pela Photon Storm. Com ela, podemos criar jogos que rodam tanto em ambiente mobile quanto desktops. Ela roda nos principais navegadores atuais de desktop. Em dispositivos móveis, é suportado no Chrome mobile, no navegador Safari (no IOS5 para cima). Acesse a biblioteca: phaser.io

Principais recursos:

O Phaser não utiliza nenhuma prática interna de orientação a objeto, não possui heranças de código e componentes. Mas você pode alterar as funções do Phaser.

Para renderização de gráficos, o Phaser utiliza o Pixi.js. Nos jogos, se o navegador suportar WebGL, o usuário terá uma melhor experiência. Os jogos em HTML5 caminham para o futuro de WebGL disponível em dispositivos móveis. Para isso acontecer, é apenas uma questão de tempo.

O carregamento do Phaser suporta:

  1. Imagens;

  2. Sprite Sheets;

  3. Texture Atlases;

  4. Arquivos de áudio;

  5. Arquivos de dados;

  6. Arquivos JavaScript;

  7. Tilemaps;

  8. Fontes Bitmap.

Áudio:

Com a WebAudio API, podemos ter uma integração apropriada de áudio, com múltiplas rotas, canais e os mais variados tipos de efeitos.

Inputs:

Multi-Touch, Keyboard, Pointer e Mouse: O Phaser suporta os mais variados tipos de inputs, como toques na tela, cliques de mouse, teclas pressionadas, entre outros.

Continue lendo “Conheça o Phaser.JS, uma biblioteca de criação de jogos JavaScript”