roxify 1.1.7 → 1.1.8

package/README.md

@@ -28,8 +28,8 @@ npm install roxify
 
 ```bash
 npx rox encode <inputName>.ext (<outputName>.png)
-
 npx rox decode <inputName>.png (<outputName>.ext)
+npx rox list <inputName>.png
 ```
 
 If no output name is provided:
@@ -37,154 +37,71 @@ If no output name is provided:
 - Encoding: output defaults to `<inputName>.png`.
 - Decoding: if the image contains the original filename it will be restored; otherwise the output will be `decoded.bin`.
 
-**Commands:**
-
-- `encode <input>... [output]` — Encode file(s)/directory to PNG
-- `decode <input> [output]` — Decode PNG to file(s)
-- `list <input>` — List files in archive without decoding
-
 **Options:**
 
 - `-p, --passphrase <pass>` — Encrypt with AES-256-GCM
-- `-m, --mode <mode>` — Encoding mode: `screenshot` (default), `pixel`, `compact`, `chunk`
-- `-q, --quality <0-22>` — Roxify compression level (default: 22)
-- `--no-compress` — Disable compression
-- `--files <list>` — Extract only specified files (comma-separated, for archives)
 - `-v, --verbose` — Show detailed errors
 
 Run `npx rox help` for full options.
 
 ## API Usage
 
+### Basic Encoding and Decoding
+
 ```js
-import { encodeBinaryToPng, decodePngToBinary, listFilesInPng } from 'roxify';
+import { readFileSync, writeFileSync } from 'fs';
+import { encodeBinaryToPng } from 'roxify';
 
-// Encode a file
-const data = Buffer.from('Hello world');
-const png = await encodeBinaryToPng(data, {
-  mode: 'screenshot',
-  name: 'message.txt',
+const fileName = 'input.bin';
+const inputBuffer = readFileSync(fileName);
+const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+  name: fileName,
 });
-
-// Decode
-const { buf, meta } = await decodePngToBinary(png);
-console.log(buf.toString('utf8'));
-console.log(meta?.name);
-
-// List files in archive
-const files = listFilesInPng(png);
-console.log(files);
-
-// Selective extraction
-const result = await decodePngToBinary(png, { files: ['file1.txt'] });
-if (result.files) {
-  // result.files contains only the selected files
-}
+writeFileSync('output.png', pngBuffer);
 ```
 
-## Example: Progress Logging
+```js
+import { readFileSync, writeFileSync } from 'fs';
+import { decodePngToBinary } from 'roxify';
 
-````js
-import { encodeBinaryToPng, decodePngToBinary } from 'roxify';
+const pngFromDisk = readFileSync('output.png');
+const { buf, meta } = await decodePngToBinary(pngFromDisk);
+writeFileSync(meta?.name ?? 'decoded.txt', buf);
+```
 
-const data = Buffer.from('Large data to encode...');
+### With Passphrase
 
-// Encode with progress logging
-const png = await encodeBinaryToPng(data, {
-  onProgress: (info) => {
-    console.log(`Encoding phase: ${info.phase}`);
-    if (info.loaded && info.total) {
-      const percent = Math.round((info.loaded / info.total) * 100);
-      console.log(`Progress: ${percent}% (${info.loaded}/${info.total} bytes)`);
-    }
-  },
+```js
+const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+  name: fileName,
+  passphrase: 'mysecret',
 });
-
-
-Node.js (detailed chunk progress example)
+```
 
 ```js
-import { encodeBinaryToPng } from 'roxify';
-import { readFileSync, writeFileSync } from 'fs';
-
-const buf = readFileSync('test-data/testVideo.mp4');
-const png = await encodeBinaryToPng(buf, {
-  showProgress: false,
-  onProgress(info) {
-    if (info.phase === 'compress_progress' && info.loaded && info.total) {
-      const percent = Math.round((info.loaded / info.total) * 100);
-      console.log(`[progress] ${info.phase} ${percent}% (${info.loaded}/${info.total} chunks)`);
-    } else {
-      console.log(`[progress] ${info.phase} ${info.loaded || ''}/${info.total || ''}`);
-    }
-  },
+const { buf, meta } = await decodePngToBinary(pngFromDisk, {
+  passphrase: 'mysecret',
 });
+```
 
-writeFileSync('out.png', png);
-````
+### With Progress Logging
 
-// Decode with progress logging
-const { buf } = await decodePngToBinary(png, {
-onProgress: (info) => {
-console.log(`Decoding phase: ${info.phase}`);
-},
+```js
+const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+  name: fileName,
+  onProgress: (info) => {
+    console.log(`Phase: ${info.phase}, Loaded: ${info.loaded}/${info.total}`);
+  },
 });
-
-````
-
-**API:**
-
-- `encodeBinaryToPng(input: Buffer, opts?: EncodeOptions): Promise<Buffer>`
-- `decodePngToBinary(pngBuf: Buffer, opts?: DecodeOptions): Promise<DecodeResult>`
-- `listFilesInPng(pngBuf: Buffer): string[] | null`
-
-**EncodeOptions:**
-
-- `mode` — `'screenshot'` | `'pixel'` | `'compact'` | `'chunk'` (default: `'screenshot'`)
-- `name` — Original filename (embedded as metadata)
-- `passphrase` — Encryption passphrase (uses AES-256-GCM)
-- `compression` — `'Roxify'` | `'none'` (default: `'Roxify'`)
-- `brQuality` — Roxify compression level 0-22 (default: 22)
-- `showProgress` — Display progress bar (default: `false`)
-- `onProgress` — Callback for progress updates: `(info: { phase: string; loaded?: number; total?: number }) => void`
-- `includeFileList` — Include file list for archives (default: `true` for directories)
-
-**DecodeOptions:**
-
-- `passphrase` — Decryption passphrase
-- `files` — List of files to extract selectively (for archives)
-- `showProgress` — Display progress bar (default: `false`)
-- `onProgress` — Callback for progress updates: `(info: { phase: string; loaded?: number; total?: number }) => void`
-
-**DecodeResult:**
-
-- `buf?: Buffer` — Decoded data (if not selective extraction)
-- `files?: PackedFile[]` — Extracted files (if selective extraction)
-- `meta?: { name?: string }` — Metadata
-
-## Example: Archive with Selective Extraction
+```
 
 ```js
-import { encodeBinaryToPng, decodePngToBinary, listFilesInPng } from 'roxify';
-
-// Pack a directory
-const fs = require('fs');
-const dirData = packPaths(['myfolder']); // From pack.js
-const png = await encodeBinaryToPng(dirData.buf, {
-  includeFileList: true,
-  fileList: dirData.list,
+const { buf, meta } = await decodePngToBinary(pngFromDisk, {
+  onProgress: (info) => {
+    console.log(`Phase: ${info.phase}, Loaded: ${info.loaded}/${info.total}`);
+  },
 });
-
-// List files without decoding
-const files = listFilesInPng(png);
-console.log('Files:', files);
-
-// Extract only one file
-const result = await decodePngToBinary(png, { files: ['myfolder/file.txt'] });
-if (result.files) {
-  fs.writeFileSync('extracted.txt', result.files[0].buf);
-}
-````
+```
 
 ## Requirements
 

package/dist/index.d.ts

@@ -157,6 +157,19 @@ export declare function cropAndReconstitute(input: Buffer, debugDir?: string): P
  * @param input - Data to encode
  * @param opts - Encoding options
  * @public
+ * @example
+ * ```typescript
+* import { readFileSync, writeFileSync } from 'fs';
+* import { encodeBinaryToPng } from 'roxify';
+*
+* const fileName = 'input.bin'; //Path of your input file here
+* const inputBuffer = readFileSync(fileName);
+* const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+*   name: fileName,
+* });
+* writeFileSync('output.png', pngBuffer);
+
+ * ```
  */
 export declare function encodeBinaryToPng(input: Buffer, opts?: EncodeOptions): Promise<Buffer>;
 /**
@@ -166,6 +179,13 @@ export declare function encodeBinaryToPng(input: Buffer, opts?: EncodeOptions):
  * @param pngBuf - PNG data
  * @param opts - Options (passphrase for encrypted inputs)
  * @public
+ * @example
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { decodePngToBinary } from 'roxify';
+ *
+ * const pngFromDisk = readFileSync('output.png'); //Path of the encoded PNG here
+ * const { buf, meta } = await decodePngToBinary(pngFromDisk);
+ * writeFileSync(meta?.name ?? 'decoded.txt', buf);
  */
 export declare function decodePngToBinary(pngBuf: Buffer, opts?: DecodeOptions): Promise<DecodeResult>;
 export { packPaths, unpackBuffer } from './pack.js';

package/dist/index.js

@@ -537,6 +537,19 @@ export async function cropAndReconstitute(input, debugDir) {
  * @param input - Data to encode
  * @param opts - Encoding options
  * @public
+ * @example
+ * ```typescript
+* import { readFileSync, writeFileSync } from 'fs';
+* import { encodeBinaryToPng } from 'roxify';
+*
+* const fileName = 'input.bin'; //Path of your input file here
+* const inputBuffer = readFileSync(fileName);
+* const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+*   name: fileName,
+* });
+* writeFileSync('output.png', pngBuffer);
+
+ * ```
  */
 export async function encodeBinaryToPng(input, opts = {}) {
     let progressBar = null;
@@ -887,6 +900,13 @@ export async function encodeBinaryToPng(input, opts = {}) {
  * @param pngBuf - PNG data
  * @param opts - Options (passphrase for encrypted inputs)
  * @public
+ * @example
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { decodePngToBinary } from 'roxify';
+ *
+ * const pngFromDisk = readFileSync('output.png'); //Path of the encoded PNG here
+ * const { buf, meta } = await decodePngToBinary(pngFromDisk);
+ * writeFileSync(meta?.name ?? 'decoded.txt', buf);
  */
 export async function decodePngToBinary(pngBuf, opts = {}) {
     let progressBar = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Encode binary data into PNG images with Zstd compression and decode them back. Supports CLI and programmatic API (Node.js ESM).",
   "type": "module",
   "main": "dist/index.js",
@@ -21,16 +21,19 @@
   "keywords": [
     "steganography",
     "png",
-    "brotli",
-    "rox",
-    "compress",
-    "decompress",
+    "zstd",
+    "compression",
+    "encryption",
     "encode",
     "decode",
     "cli",
     "nodejs",
     "esm",
-    "qrcode"
+    "data-embedding",
+    "file-archive",
+    "lossless",
+    "aes-gcm",
+    "binary-data"
   ],
   "author": "RoxCompressor",
   "license": "UNLICENSED",