@vvlad1973/crypto 2.1.1 → 2.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vvlad1973/crypto",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/.vscode/launch.json

@@ -1,20 +0,0 @@
-{
-    // Используйте IntelliSense, чтобы узнать о возможных атрибутах.
-    // Наведите указатель мыши, чтобы просмотреть описания существующих атрибутов.
-    // Для получения дополнительной информации посетите: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "env": {
-                "NODE_OPTIONS": "--experimental-vm-modules"
-            },
-            "name": "Запустить программу",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "program": "${workspaceFolder}\\index.js"
-        }
-    ]
-}

package/CLAUDE.md

@@ -1,90 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Common requirements
-
-- отвечай на русском языке. Используй английский только если на то есть особые указания
-- комментарии в коде, в JSDoc - используй английский язык
-- отчеты - используй русский язык
-- при создании документов и commit messages НИКОГДА НЕ ДОБАВЛЯЙ в нихх никакой информации о том, что этот текст сгенерирован тобой, либо при твоем участии/соавторстве
-- при формировании и редактировании файлов *.md соблюдай синтаксис MarkDown. Все Markdown-файлы (*.md) ДОЛЖНЫ проходить проверку линтером без ошибок и предупреждений
-- Не вноси изменений в CHANGELOG.md, этот файл формируется автоматически
-- **НИКОГДА НЕ ИСПОЛЬЗУЙ EMOJI** в файлах .md - это строгое требование проекта без исключений
-- при подготовке файлов документации соблюдай структуру каталога docs, правила, изложенные в C:\Repositories\botApp\bot-app-service\docs\CONTRIBUTING.md
-
-## Project Overview
-
-TypeScript library providing AES-256-CTR encryption/decryption functionality. Wrapper around Node.js native `crypto` module, replacing the previous `aes-js` dependency.
-
-## Development Commands
-
-### Build
-```bash
-npm run build
-```
-Compiles TypeScript to JavaScript using `tsc`. Output: `dist/` directory with `.js` and `.d.ts` files.
-
-### Testing
-```bash
-npm test
-```
-Runs build followed by Node.js native test runner with ts-node loader.
-
-To run a specific test file:
-```bash
-npm run build && node --loader ts-node/esm --test src/__tests__/crypto.test.ts
-```
-
-### Documentation Generation
-```bash
-npm run doc
-```
-Generates JSDoc documentation using better-docs template. Output: `docs/` directory.
-
-## Architecture
-
-### Core Module Structure
-- [src/crypto.ts](src/crypto.ts) - Main `Crypto` class implementation
-- [src/index.ts](src/index.ts) - Module exports
-- [src/__tests__/crypto.test.ts](src/__tests__/crypto.test.ts) - Test suite
-
-### Crypto Class Design
-
-The `Crypto` class uses Node.js native crypto APIs:
-- **Key derivation**: `pbkdf2Sync` with configurable algorithm (default SHA512), iterations (1000), and key length (32 bytes)
-- **Encryption**: AES-256-CTR mode via `createCipheriv`
-- **Initialization Vector (IV)**: Accepts either Buffer or number (converted to 16-byte Buffer)
-
-Constructor supports two signatures:
-1. Individual parameters: `new Crypto(password, salt, algorithm?, iterations?, keyLength?, iv?)`
-2. Options object: `new Crypto({ password, salt, algorithm?, iterations?, keyLength?, iv? })`
-
-### Key Implementation Details
-
-- IV conversion from number: Uses `Buffer.alloc(16)` with `writeUInt32BE` at offset 12
-- Encryption output: Hex-encoded string
-- Type guard: `isCrypto(object)` function checks for `encrypt` and `decrypt` methods
-- Static method: `Crypto.getUUID()` returns UUIDv4 string using `crypto.randomUUID()`
-
-### Module System
-- ES modules (`"type": "module"` in package.json)
-- TypeScript target: ES2022
-- File extensions: Import paths must use `.js` extension (not `.ts`) due to ES module resolution
-
-## TypeScript Configuration
-
-Strict mode enabled with full type checking. Output includes declaration files for TypeScript consumers.
-
-## Testing Approach
-
-Tests use Node.js native test runner (`node:test`) with:
-- Encryption/decryption round-trip verification
-- Both constructor signatures
-- Default parameter handling
-- Type guard validation
-- Backward compatibility with previous library version (validates specific encrypted output)
-
-## JSDoc Requirements
-
-Per user instructions: All modules must include complete JSDoc with module definitions. Comments and JSDoc must be in English.

package/src/__tests__/crypto.test.ts

@@ -1,238 +0,0 @@
-import { describe, it, beforeEach, expect } from 'vitest';
-import { randomBytes } from 'crypto';
-import Crypto, { CryptoOptions, isCrypto } from '../crypto.js';
-
-describe('Crypto', () => {
-  const plainText = 'Hello, World!';
-  let options: CryptoOptions;
-  let password: string;
-  let salt: string;
-  let algorithm: string;
-  let iterations: number;
-  let keyLength: number;
-  let iv: number;
-
-  beforeEach(() => {
-    options = {
-      password: 'testPassword',
-      salt: 'testSalt',
-      algorithm: 'SHA512',
-      iterations: 1000,
-      keyLength: 32,
-      iv: 5,
-    };
-    password = 'testPassword';
-    salt = 'testSalt';
-    algorithm = 'SHA512';
-    iterations = 1000;
-    keyLength = 32;
-    iv = 5;
-  });
-
-  it('should initialize with CryptoOptions object', () => {
-    const crypto = new Crypto(options);
-    expect(crypto).toBeDefined();
-  });
-
-  it('should initialize with separate parameters', () => {
-    const crypto = new Crypto(
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      iv
-    );
-    expect(crypto).toBeDefined();
-  });
-
-  it('should return UUIDv4', () => {
-    const crypto = new Crypto(options);
-    const uuid = Crypto.getUUID();
-    const uuidv4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    expect(uuid).toMatch(uuidv4Regex);
-  });
-
-  it('should encrypt and decrypt text correctly using ICryptoOptions', () => {
-    const crypto = new Crypto(options);
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should encrypt and decrypt text correctly using separate parameters', () => {
-    const crypto = new Crypto(
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      iv
-    );
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should handle default values for optional parameters', () => {
-    const cryptoWithDefaults = new Crypto(password, salt);
-    const encryptedText = cryptoWithDefaults.encrypt(plainText);
-    const decryptedText = cryptoWithDefaults.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should initialize with Buffer IV using options object', () => {
-    const ivBuffer = randomBytes(16);
-    const crypto = new Crypto({
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      iv: ivBuffer,
-    });
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should initialize with Buffer IV using separate parameters', () => {
-    const ivBuffer = randomBytes(16);
-    const crypto = new Crypto(
-      password,
-      salt,
-      algorithm,
-      iterations,
-      keyLength,
-      ivBuffer
-    );
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should initialize without IV (random generation via options)', () => {
-    const crypto1 = new Crypto({ password, salt });
-    const crypto2 = new Crypto({ password, salt });
-    const encrypted1 = crypto1.encrypt(plainText);
-    const encrypted2 = crypto2.encrypt(plainText);
-    // Should produce different encrypted results due to different random IVs
-    expect(encrypted1).not.toBe(encrypted2);
-  });
-
-  it('should handle empty string encryption and decryption', () => {
-    const crypto = new Crypto(options);
-    const emptyText = '';
-    const encryptedText = crypto.encrypt(emptyText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(emptyText);
-  });
-
-  it('should handle Unicode characters', () => {
-    const crypto = new Crypto(options);
-    const unicodeText = '🔐 Encryption test 中文 العربية';
-    const encryptedText = crypto.encrypt(unicodeText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(unicodeText);
-  });
-
-  it('should handle different hash algorithms', () => {
-    const crypto256 = new Crypto(password, salt, 'sha256', iterations, keyLength, iv);
-    const encryptedText = crypto256.encrypt(plainText);
-    const decryptedText = crypto256.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should handle different key lengths', () => {
-    // AES-256-CTR requires 32 bytes key, testing with valid 32 bytes
-    const crypto32 = new Crypto(password, salt, algorithm, iterations, 32, iv);
-    const encryptedText = crypto32.encrypt(plainText);
-    const decryptedText = crypto32.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should handle different iteration counts', () => {
-    const crypto = new Crypto(password, salt, algorithm, 5000, keyLength, iv);
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-});
-
-describe('isCrypto', () => {
-  const validCryptoOptions: CryptoOptions = {
-    password: 'testPassword',
-    salt: 'testSalt',
-    algorithm: 'SHA512',
-    iterations: 1000,
-    keyLength: 32,
-    iv: 5,
-  };
-
-  it('should return true for a valid Crypto instance created with ICryptoOptions', () => {
-    const crypto = new Crypto(validCryptoOptions);
-    expect(isCrypto(crypto)).toBe(true);
-  });
-
-  it('should return true for a valid Crypto instance created with separate parameters', () => {
-    const crypto = new Crypto(
-      validCryptoOptions.password,
-      validCryptoOptions.salt,
-      validCryptoOptions.algorithm,
-      validCryptoOptions.iterations,
-      validCryptoOptions.keyLength,
-      validCryptoOptions.iv
-    );
-    expect(isCrypto(crypto)).toBe(true);
-  });
-
-  it('should return false for null', () => {
-    const nullObject = null;
-    expect(isCrypto(nullObject)).toBe(false);
-  });
-
-  it('should return false for undefined', () => {
-    const undefinedObject = undefined;
-    expect(isCrypto(undefinedObject)).toBe(false);
-  });
-
-  it('should return false for a plain object without encrypt and decrypt methods', () => {
-    const plainObject = {
-      someMethod: () => {},
-    };
-    expect(isCrypto(plainObject)).toBe(false);
-  });
-});
-
-describe('Compatibility with previous version', () => {
-
-  const plainText = 'Проверка связи';
-  let options: CryptoOptions;
-  let encText = 'a4661cb701751a895f65418ed488faad33da3090d05ad661f0a7a9';
-
-  beforeEach(() => {
-    options = {
-      algorithm: 'SHA512',
-      iv: 5,
-      keyLength: 32,
-      iterations: 1000,
-      password: 'password',
-      salt: 'saltsaltsalt',
-    };
-  });
-
-  it('should return correct string', () => {
-    const crypto = new Crypto(options);
-
-    const decryptedText = crypto.decrypt(encText);
-    expect(decryptedText).toBe(plainText);
-  });
-
-  it('should return correct encrypt-decrypt', () => {
-    const crypto = new Crypto(options);
-
-    const encryptedText = crypto.encrypt(plainText);
-    const decryptedText = crypto.decrypt(encryptedText);
-    expect(decryptedText).toBe(plainText);
-  });
-});

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "node",
-    "strict": true,
-    "esModuleInterop": true,
-    "outDir": "./dist",
-    "declaration": true,
-    "skipLibCheck": true
-  },
-  "include": [
-    "./src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "coverage",
-    "docs"
-  ]
-}

package/vitest.config.ts

@@ -1,36 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  resolve: {
-    extensions: ['.ts', '.js']
-  },
-  test: {
-    environment: 'node',
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'html', 'lcov', 'json'],
-      reportsDirectory: './coverage',
-      clean: true,
-      exclude: [
-        'node_modules/**',
-        'dist/**',
-        'docs/**',
-        'coverage/**',
-        '**/__tests__/**',
-        '**/*.test.ts',
-        '**/*.spec.ts',
-        '**/*.config.ts',
-        '**/index.ts'
-      ],
-      include: ['src/crypto.ts'],
-      thresholds: {
-        lines: 90,
-        functions: 85,
-        branches: 90,
-        statements: 90
-      }
-    },
-    include: ['src/**/__tests__/**/*.test.ts'],
-    exclude: ['node_modules', 'dist', 'docs']
-  }
-});