encoding-tools 0.0.2 → 0.0.6

package/encoding-tools

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/**    ------------------------------------------------------------------
+ *     Copyright ©
+ *       Pellegrino Prevete
+ *         2024, 2025, 2026
+ * 
+ *     All rights reserved
+ *     ------------------------------------------------------------------
+ * 
+ *     This program is free software: you can redistribute it and/or
+ *     modify it under the terms of the GNU General Public License as
+ *     published by the Free Software Foundation, either version 3 of
+ *     the License, or (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.
+ *     If not, see <https://www.gnu.org/licenses/>.
+ */
+
+const
+  _bin2txt_module =
+    require(
+      "./libbin2txt");
+const
+  _bin2txt =
+    _bin2txt_module._bin2txt;
+const
+  _txt2bin_module =
+    require(
+      "./libtxt2bin");
+const
+  _txt2bin =
+    _txt2bin_module._txt2bin;
+
+module.exports = {
+  _bin2txt:
+    _bin2txt,
+  _txt2bin:
+    _txt2bin
+};

package/libbin2txt

@@ -27,46 +27,107 @@
  *     If not, see <https://www.gnu.org/licenses/>.
  */
 
+/* eslint-disable
+     no-unused-vars */
+
 const
   _libcrash =
   require(
-    'crash-js');
+    "crash-js");
+/* global
+     _cat */
+const
+  _cat =
+    _libcrash._cat;
+/* global
+     _dirname */
+const
+  _dirname =
+    _libcrash._dirname;
+/* global
+     _error_display */
 const
   _error_display =
     _libcrash._error_display;
+/* global
+     _ext_rm */
 const
   _ext_rm =
     _libcrash._ext_rm;
+/* global
+     _file_exists */
+const
+  _file_exists =
+    _libcrash._file_exists;
+/* global
+     _file_read */
 const
   _file_read =
     _libcrash._file_read;
+/* global
+     _file_write */
 const
   _file_write =
     _libcrash._file_write;
+/* global
+     _fs_worker_start */
 const
   _fs_worker_start =
     _libcrash._fs_worker_start;
+/* global
+     _json_read */
 const
   _json_read =
     _libcrash._json_read;
+/* global
+     _ls */
 const
   _ls =
     _libcrash._ls;
+/* global
+     _mkdir */
 const
   _mkdir =
     _libcrash._mkdir;
+/* global
+     _msg_info */
 const
   _msg_info =
     _libcrash._msg_info;
+/* global
+     _msg_error */
 const
   _msg_error =
     _libcrash._msg_error;
+/* global
+     _printf */
 const
-  _split =
-    _libcrash._split;
+  _printf =
+    _libcrash._printf;
+/* global
+     _rm */
+const
+  _rm =
+    _libcrash._rm;
+/* global
+     _seq */
+const
+  _seq =
+    _libcrash._seq;
+/* global
+     _stat */
 const
   _stat =
     _libcrash._stat;
+const
+  _tmcsplit =
+    require(
+      "tmcsplit");
+/* global
+     _split */
+const
+  _split =
+    _tmcsplit._split;
 
 async function
   _buffer_prepare(
@@ -74,39 +135,233 @@ async function
     _out,
     _buffer_size_bytes) {
   let
-    _in_size_bytes,
-    _split_opts,
     _msg;
-  _split_opts =
-    [];
-  console.log(
-    _stat);
-  console.log(
-    _in);
-  console.log(
-    _out);
-  // _in_size_bytes="$( \
-  //   du \
-  //     -bs \
-  //     "${_in}" | \
-  //     awk \
-  //       '{print $1}')"
-  // _msg=(
-  //   "File '${_in}' has size"
-  //   "'${_in_size_bytes}' bytes."
-  // )
-  // _msg_info \
-  //   "${_msg[*]}"
-  // _blocks_total="$(( \
-  //   _in_size_bytes / _buffer_size_bytes + 1))"
-  // split \
-  //   -n \
-  //     "l/${_blocks_total}" \
-  //   --numeric-suffixes="1" \
-  //   "${_in}" \
-  //   "${_out}.block."
-  // _blocks_find \
-  //   "${_out}.block"
+  const
+    _size_max =
+      0;
+  const
+    _in_size_bytes =
+      _stat(
+        _in).size;
+  _msg =
+    `File '${_in}' has size ` +
+    `'${_in_size_bytes}' bytes.`;
+  _msg_info(
+    _msg);
+  const
+    _blocks_total =
+      Math.ceil(
+        _in_size_bytes /
+        _buffer_size_bytes);
+  _msg =
+    `Splitting file '${_in}' in ` +
+    `'${_blocks_total}' blocks of ` +
+    `'${_buffer_size_bytes}' bytes.`;
+  _msg_info(
+    _msg);
+  const
+    _split_opts = [
+      _in,
+      `${_out}.block.`,
+      _blocks_total,
+      _size_max
+    ];
+  const
+    _output_files =
+      await _split.apply(
+        null,
+        _split_opts);
+  _msg =
+    "Done.";
+  _msg_info(
+    _msg);
+  return _output_files;
+}
+
+function
+  _base64_block_encode(
+    _file) {
+  let
+    _string;
+  const
+    _content =
+      _cat(
+        _file);
+  if ( typeof window === 'undefined' &&
+       ( typeof global !== 'undefined' &&
+         global.global === global ) &&
+       typeof __webpack_require__ !== 'function' ) {
+    const
+      _buffer =
+        Buffer.from(
+          _content);
+    _string =
+      _buffer.toString(
+        "base64");
+  }
+  else {
+    _string =
+      btoa(
+        _string);
+  }
+  return _string;
+}
+
+async function
+  _chunk_split(
+    _in,
+    _chunk_current,
+    _length,
+    _prefix,
+    _block_last) {
+  let
+    _chunk,
+    _chunk_start,
+    _content,
+    _cut,
+    _msg,
+    _out;
+  const
+    _total =
+      _in.length;
+  const
+    _chunks =
+      Math.ceil(
+        _chunk_current +
+        _total /
+          _length);
+  if ( _chunks < 2 ) {
+    _out =
+      _prefix;
+    _file_write(
+      _out,
+      _in);
+    return 0;
+  }
+  _msg =
+    `Chunking '${_total}' ` +
+    `letters into '${_chunks}' ` +
+    `chunks of length '${_length}'.`;
+  _msg_info(
+    _msg);
+  for ( _chunk of _seq(
+                    _chunk_current + 1,
+                    _chunks) ) {
+    _chunk_start =
+      ( ( _chunk -
+          _chunk_current ) *
+        _length ) -
+      _length;
+    _cut =
+      _in.substring(
+        _chunk_start,
+        _chunk_start + _length);
+    _out =
+      `${_prefix}.${_chunk}`;
+    _msg =
+      `Writing chunk ${_chunk} in file '${_out}' ` +
+      `of length ${_cut.length} out of ${_chunks}.`;
+    _msg_info(
+      _msg);
+    if ( _chunk < _chunks ) {
+      _printf(
+        _out,
+        _cut);
+    }
+    else if ( _chunk == _chunks ) {
+      if ( _block_last == "true" ) {
+        _file_write(
+          _out,
+          _cut);
+      }
+      else if ( _block_last == "false" ) {
+        _msg =
+          "Last chunk of non-last block, " +
+          "adding a newline character at the end (nope).";
+        _msg_info(
+          _msg);
+        _file_write(
+          _out,
+          _cut);
+      }
+    }
+  }
+  _chunk_current =
+    _chunks;
+  _msg=
+    "Finished encoding block.";
+  _msg_info(
+    _msg);
+  return _chunk_current;
+}
+
+async function
+  _base64_encode(
+    _block,
+    _chunk_current,
+    _length,
+    _out,
+    _block_last,
+    _amount_only) {
+  let
+    _msg;
+  const
+    _txt =
+      _base64_block_encode(
+        _block);
+  _msg =
+    `Block '${_block}' encoded ` +
+    `length: ${_txt.length}.`;
+  _msg_info(
+    _msg);
+  if ( _amount_only === "false" ) {
+    _chunk_current =
+      await _chunk_split(
+        _txt,
+        _chunk_current,
+        _length,
+        _out,
+        _block_last);
+  }
+  else if ( _amount_only === "true" ) {
+    const
+      _chunks_total =
+        Math.ceil(
+          _chunks_total +
+          _txt.length /
+            _length);
+    _chunk_current =
+      _chunks_total;
+  }
+  else {
+    _msg =
+      `Value of the 'amount_only' can ` +
+      `be true or false. Current: '${_amount_only}'.`;
+    _msg_error(
+      _msg,
+      1);
+  }
+  _msg =
+    "Finished encoding block " +
+    `'${_block}'.`;
+  _msg_info(
+    _msg);
+  return _chunk_current;
+}
+
+async function
+  _input_data_check(
+    _in) {
+  if ( ! _file_exists(
+           _in) ) {
+    const
+      _msg =
+        `File '${_in}' does ` +
+        'not exist.';
+    _msg_error(
+      _msg,
+      1);
+  }
 }
 
 async function
@@ -118,71 +373,102 @@ async function
     _buffer_size_bytes,
     _amount_only) {
   let
-    _blocks_total,
-    _chunks_total,
+    _block,
     _chunk_current,
+    _chunks_total,
     _block_current,
     _block_last,
-    _dir,
-    _file,
     _msg,
+    _rm_args,
     _worker;
-  _dir =
-    "/test_dir";
-  _file =
-    `${_dir}/test_file`;
-  _content =
-    `${_in} ${_out}`;
   if ( typeof window !== 'undefined' ) {
-    await _fs_worker_start(
-        "fs-worker.js");
+    const
+      _worker =
+        await _fs_worker_start(
+          "fs-worker.js");
+    _msg =
+      `OPFS worker '${_worker}' started.`;
+    _msg_info(
+      _msg);
+  }
+  _input_data_check(
+    _in);
+  const
+    _blocks =
+      await _buffer_prepare(
+        _in,
+        _out,
+        _buffer_size_bytes);
+  const
+    _blocks_total =
+      _blocks.length;
+  _chunk_current =
+    0;
+  _block_current =
+    1;
+  for ( _block of _blocks ) {
+    _msg =
+      `Reading block '${_block}' ` +
+      `('${_block_current}' ` +
+      `of '${_blocks_total}').`;
+    _msg_info(
+      _msg);
+    if ( _block_current < _blocks_total ) {
+      _block_last =
+        "false";
+    }
+    else if ( _block_current == _blocks_total ) {
+      _block_last =
+        "true";
+    }
+    if ( _format === "base64" ) {
+      _chunk_current =
+        _base64_encode(
+          _block,
+          _chunk_current,
+          _length,
+          _out,
+          _block_last,
+          _amount_only);
+      _msg_info(
+        `Current chunk: '${_chunk_current}'.`);
+    _block_current =
+      _block_current + 1;
+    }
+    else {
+      _msg =
+        "Unknown encoding format " +
+        `${_format}.`;
+      _msg_error(
+        _msg,
+        1);
+    }
+  }
+  for ( _block of _blocks ) {
+    _rm_args = [
+      _block
+    ];
+    _rm(
+      _rm_args);
+  }
+  if ( _amount_only === "true" ) {
+    _chunks_total =
+      _chunk_current;
+    _msg =
+      `File '${_in}' is base64 encoded and ` +
+      `split in '${_chunks_total}' ` +
+      `files of length '${_length}'.`;
+    _msg_info(
+      _msg);
+    return _chunks_total;
+  }
+  else if ( _amount_only === "false" ) {
+    _msg =
+      `Finished '${_format}' encoding ` +
+      `input file '${_in}'.`;
+    _msg_info(
+      _msg);
   }
-  _buffer_prepare(
-    _in,
-    _out,
-    _buffer_size_bytes);
-  // _split(
-  //   "",
-  //   2);
-  // _split(
-  //   _input_file,
-  //   _output_prefix,
-  //   _chunks_amount,
-  //   _size_max) {
-  // console.log(
-  //   _split
-  // );
-  // _msg =
-  //   `Creating directory '${_dir}':`;
-  // _msg_info(
-  //   _msg);
-  // _mkdir(
-  //   _dir);
-  // _msg =
-  //   `Writing content '${_content}' to file '${_file}':`;
-  // _msg_info(
-  //   _msg);
-  // _file_write(
-  //   _file,
-  //   _content);
-  // _msg =
-  //   `Content of directory '/':`;
-  // _msg_info(
-  //   _msg);
-  // _dir_content =
-  //   _ls(
-  //     "/").unwrap();
-  // console.log(
-  //   _dir_content);
-  // _msg =
-  //   `Content of directory '${_dir}':`;
-  // _msg_info(
-  //   _msg);
-  // _dir_content =
-  //   _ls(
-  //     _dir).unwrap();
-  // console.log(
-  //   _dir_content);
 }
 
 module.exports = {