cesar-cipher - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

dist/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.crypt = crypt;
-const defaultAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+const defaultAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ÇÃÉÀÊÓÁÔÍ'.split('');
 function isWhitespace(char) {
     return char === ' ';
 }
+function isEncryptedWhitespace(char) {
+    return char === '+';
+}
 function appendToMessage(char, message) {
@@ -20,2 +23,9 @@ return message + char;
 }
+function findNewChar(char, chain, shift) {
+    const totalNumbers = chain.length;
+    const currentIndex = chain.indexOf(char);
+    const shiftedIndex = (currentIndex + shift) % totalNumbers;
+    const newChar = chain[shiftedIndex];
+    return newChar;
+}
 function shiftMessage(message, shift, alphabet) {
@@ -25,11 +35,11 @@ validateShift(shift, alphabet);
         if (isWhitespace(char)) {
-            return appendToMessage(char, acc);
+            return appendToMessage('+', acc);
         }
+        if (isEncryptedWhitespace(char)) {
+            return appendToMessage(' ', acc);
+        }
         if (!isInAlphabet(char, alphabet)) {
             return appendToMessage('?', acc);
         }
-        const totalLetters = alphabet.length;
-        const currentIndex = alphabet.indexOf(char);
-        const shiftedIndex = (currentIndex + shift) % totalLetters;
-        const newChar = alphabet[shiftedIndex];
+        const newChar = findNewChar(char, alphabet, shift);
         return appendToMessage(newChar, acc);
@@ -42,4 +52,4 @@ }, "");
     return {
-        decrypt: (message) => shiftMessage(message, alphabet.length - shift, alphabet),
-        encrypt: (message) => shiftMessage(message, shift, alphabet),
+        decrypt: (message) => { var _a; return shiftMessage(((_a = message === null || message === void 0 ? void 0 : message.toString()) !== null && _a !== void 0 ? _a : '').toUpperCase(), alphabet.length - shift, alphabet); },
+        encrypt: (message) => { var _a; return shiftMessage(((_a = message === null || message === void 0 ? void 0 : message.toString()) !== null && _a !== void 0 ? _a : '').toUpperCase(), shift, alphabet); },
     };
@@ -46,0 +56,0 @@ }

package.json

 {
   "name": "cesar-cipher",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A simple TypeScript library for Caesar cipher encryption and decryption",
@@ -10,3 +10,4 @@ "main": "dist/index.js",
     "prepublishOnly": "npm run build",
-    "test": "echo \"No tests specified\" && exit 0"
+    "pretest": "npm run build",
+    "test": "node test.js"
   },
@@ -13,0 +14,0 @@ "repository": {

README.md

 # Criptografia de Substituição com Shift
 
+> Apenas para fins didáticos. Não é aconselhável o uso dessa biblioteca em ambiente produtivo!
+
 Este projeto implementa um simples sistema de criptografia e descriptografia de mensagens usando o conceito de **substituição por shift** (ou cifra de César). O código permite ao usuário criptografar e descriptografar mensagens, aplicando um deslocamento (`shift`) nas letras do alfabeto.
 
-## Conceito
+---
 
+### Conceito
+
 A **cifra de César** é uma técnica de criptografia que consiste em substituir cada letra de uma mensagem pela letra que se encontra um certo número de posições à frente (ou atrás) no alfabeto. O número de posições é chamado de **shift**.
@@ -15,54 +19,48 @@
 - Shift: `3`
-- Mensagem criptografada: `PHQVDJHP VHFUHWD`
+- Mensagem criptografada: `PHQVDJHP+VHFUHWD`
 
 ### Exemplo de Descriptografia
 
-- Mensagem criptografada: `PHQVDJHP VHFUHWD`
+- Mensagem criptografada: `PHQVDJHP+VHFUHWD`
 - Shift: `3`
 - Mensagem descriptografada: `MENSAGEM SECRETA`
 
-## Estrutura do Código
+### Exemplo de Uso
 
-O código está organizado em funções simples que implementam a lógica de criptografia e descriptografia.
+Instalação
 
-### 1. **`isWhitespace(char: string): boolean`**
-Verifica se o caractere é um espaço em branco. Isso é usado para manter os espaços intactos na mensagem criptografada.
+```sh
 
-### 2. **`appendToMessage(char: string, message: string): string`**
-Adiciona um caractere ao final de uma string de mensagem.
+npm i cesar-cipher
 
-### 3. **`isInAlphabet(char: string, alphabet: string[]): boolean`**
-Verifica se o caractere faz parte do alfabeto fornecido. Isso é importante para garantir que apenas letras válidas sejam criptografadas.
+# OR
 
-### 4. **`validateShift(shift: number, alphabet: string[]): void`**
-Valida o valor do `shift` para garantir que seja positivo e menor que o tamanho do alfabeto.
+yarn add cesar-cipher
 
-### 5. **`shiftMessage(message: string, shift: number, alphabet: string[]): string`**
-Esta função é o coração do código. Ela processa a mensagem e aplica o deslocamento de acordo com o `shift` fornecido. Se o caractere for uma letra, ele será deslocado; se for um espaço em branco, ele será mantido; e se for um caractere inválido, será substituído por `?`.
+```
 
-A função usa o método `reduce` para construir a mensagem final letra por letra.
+#### Usando a lib
 
-### 6. **`crypt(alphabet: string[], shift: number)`**
-Essa função retorna um objeto com dois métodos:
-- **`encrypt(message: string): string`**: Criptografa a mensagem aplicando o `shift`.
-- **`decrypt(message: string): string`**: Descriptografa a mensagem aplicando o shift inverso (calculado como `alphabet.length - shift`).
+```typescript
 
-### Exemplo de Uso
+import { crypt } from 'cesar-cipher';
 
-```typescript
 
 // Criar um objeto de criptografia com um shift de 25
-const cipher = crypt(25); // 1 a 25
+const cipher = crypt(3); // 1 a 25
 
+
 // Criptografar uma mensagem
-const encryptedMessage = cipher.encrypt("MENSAGEM SECRETA");
-console.log(encryptedMessage); // "LDMRZFDL RDBQDSZ"
+const encryptedMessage = cipher.encrypt("OLA MUNDO");
+console.log(encryptedMessage); // "ROD+PXQGR"
 
+
 // Descriptografar a mensagem criptografada
 const decryptedMessage = cipher.decrypt(encryptedMessage);
-console.log(decryptedMessage); // "MENSAGEM SECRETA"
+console.log(decryptedMessage); // "OLA MUNDO"
 
+
 ```
 
-## Tratamento de Erros
+### Tratamento de Erros
 
@@ -73,3 +71,3 @@ - O valor do `shift` deve ser um número positivo e menor que o tamanho do alfabeto. Caso contrário, o código lançará um erro.
 
-## Como Funciona a Lógica do Shift
+### Como Funciona a Lógica do Shift
 
@@ -79,14 +77,11 @@ Para aplicar o `shift`, o código utiliza a seguinte fórmula:
 ```typescript
+
 const shiftedIndex = (currentIndex + shift) % totalLetters;
+
 ```
 
-Aqui:
-- `currentIndex` é o índice atual da letra no alfabeto.
-- `shift` é o número de posições que a letra será deslocada.
-- `totalLetters` é o tamanho do alfabeto (normalmente 26).
-
 Essa fórmula garante que, ao atingir o final do alfabeto, o deslocamento "dê a volta", começando de novo do início do alfabeto.
 
-## Conclusão
+### Conclusão
 
 Este sistema de criptografia é uma implementação simples e eficaz do método de cifra de César. Ele permite a manipulação de mensagens utilizando um deslocamento em um alfabeto customizável, aplicando boas práticas de programação em TypeScript, como validação de parâmetros e tratamento de erros.

Fixed alerts

No tests

Quality

Package does not have any tests. This is a strong signal of a poorly maintained or low quality package.

Found 1 instance in 1 package

Improved metrics

Lines of code

59

increased by20.41%

Number of low quality alerts

1

decreased by-50%

Worsened metrics

Total package byte prevSize

8146

decreased by-5.58%

Number of lines in readme file

85

decreased by-5.56%

No dependency changes