tiny-essentials 1.2.0 → 1.2.1

package/dist/v1/basics/clock.mjs

@@ -9,7 +9,8 @@
 export function getTimeDuration(timeData = new Date(), durationType = 'asSeconds', now = null) {
     if (timeData instanceof Date) {
         const currentTime = now instanceof Date ? now : new Date();
-        const diffMs = timeData - currentTime;
+        /** @type {number} */
+        const diffMs = timeData.getTime() - currentTime.getTime();
         switch (durationType) {
             case 'asMilliseconds':
                 return diffMs;
@@ -48,6 +49,17 @@ export function formatCustomTimer(totalSeconds, level = 'seconds', format = '{ti
         minutes: index >= 1,
         seconds: index >= 0,
     };
+    /**
+     * @type {{
+     *   years: number|NaN,
+     *   months: number|NaN,
+     *   days: number|NaN,
+     *   hours: number|NaN,
+     *   minutes: number|NaN,
+     *   seconds: number|NaN,
+     *   total: number|NaN
+     * }}
+     */
     const parts = {
         years: include.years ? 0 : NaN,
         months: include.months ? 0 : NaN,
@@ -64,29 +76,26 @@ export function formatCustomTimer(totalSeconds, level = 'seconds', format = '{ti
         const workingDate = new Date(baseDate);
         // Years
         if (include.years) {
-            while (new Date(workingDate.getFullYear() + 1, workingDate.getMonth(), workingDate.getDate()) <=
-                targetDate) {
+            while (new Date(workingDate.getFullYear() + 1, workingDate.getMonth(), workingDate.getDate()).getTime() <= targetDate.getTime()) {
                 workingDate.setFullYear(workingDate.getFullYear() + 1);
                 parts.years++;
             }
         }
         // Months
         if (include.months) {
-            while (new Date(workingDate.getFullYear(), workingDate.getMonth() + 1, workingDate.getDate()) <=
-                targetDate) {
+            while (new Date(workingDate.getFullYear(), workingDate.getMonth() + 1, workingDate.getDate()).getTime() <= targetDate.getTime()) {
                 workingDate.setMonth(workingDate.getMonth() + 1);
                 parts.months++;
             }
         }
         // Days
         if (include.days) {
-            while (new Date(workingDate.getFullYear(), workingDate.getMonth(), workingDate.getDate() + 1) <=
-                targetDate) {
+            while (new Date(workingDate.getFullYear(), workingDate.getMonth(), workingDate.getDate() + 1).getTime() <= targetDate.getTime()) {
                 workingDate.setDate(workingDate.getDate() + 1);
                 parts.days++;
             }
         }
-        remaining = Math.floor((targetDate - workingDate) / 1000);
+        remaining = Math.floor((targetDate.getTime() - workingDate.getTime()) / 1000);
     }
     if (include.hours) {
         parts.hours = Math.floor(remaining / 3600);
@@ -109,7 +118,16 @@ export function formatCustomTimer(totalSeconds, level = 'seconds', format = '{ti
         years: include.years ? parts.years + (parts.months || 0) / 12 + (parts.days || 0) / 365 : NaN,
     };
     parts.total = +(totalMap[level] || 0).toFixed(2).replace(/\.00$/, '');
-    const pad = (n) => (isNaN(n) ? 'NaN' : String(n).padStart(2, '0'));
+    /**
+     * Pads a number to ensure it is at least two digits long, using leading zeros if necessary.
+     *
+     * @param {number|string} n - The number or string to pad.
+     * @returns {string} The padded string.
+     */
+    const pad = (n) => {
+        const num = typeof n === 'string' ? parseInt(n) : n;
+        return Number.isNaN(num) ? 'NaN' : String(num).padStart(2, '0');
+    };
     const timeString = [
         include.hours ? pad(parts.hours) : null,
         include.minutes ? pad(parts.minutes) : null,
@@ -118,14 +136,14 @@ export function formatCustomTimer(totalSeconds, level = 'seconds', format = '{ti
         .filter((v) => v !== null)
         .join(':');
     return format
-        .replace(/\{years\}/g, parts.years)
-        .replace(/\{months\}/g, parts.months)
-        .replace(/\{days\}/g, parts.days)
+        .replace(/\{years\}/g, String(parts.years))
+        .replace(/\{months\}/g, String(parts.months))
+        .replace(/\{days\}/g, String(parts.days))
         .replace(/\{hours\}/g, pad(parts.hours))
         .replace(/\{minutes\}/g, pad(parts.minutes))
         .replace(/\{seconds\}/g, pad(parts.seconds))
         .replace(/\{time\}/g, timeString)
-        .replace(/\{total\}/g, parts.total)
+        .replace(/\{total\}/g, String(parts.total))
         .trim();
 }
 /**

package/dist/v1/basics/objFilter.cjs

@@ -74,6 +74,9 @@ const typeValidator = {
     /** Checks if the value is a Buffer. */
     buffer: (val) => typeof buffer.Buffer !== 'undefined' && buffer.Buffer.isBuffer(val),
 
+    /** Checks if the value is a File. */
+    file: (val) => typeof File !== 'undefined' && val instanceof File,
+
     /** Checks if the value is a Html Element. */
     htmlelement: (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
 
@@ -93,6 +96,7 @@ const typeValidator = {
     'function',
     'array',
     'buffer',
+    'file',
     'date',
     'regexp',
     'map',

package/dist/v1/basics/objFilter.mjs

@@ -53,6 +53,8 @@ const typeValidator = {
         promise: (val) => val instanceof Promise,
         /** Checks if the value is a Buffer. */
         buffer: (val) => typeof Buffer !== 'undefined' && Buffer.isBuffer(val),
+        /** Checks if the value is a File. */
+        file: (val) => typeof File !== 'undefined' && val instanceof File,
         /** Checks if the value is a Html Element. */
         htmlelement: (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
         /** Checks if the value is a non-null plain object or instance of a class. */
@@ -70,6 +72,7 @@ const typeValidator = {
         'function',
         'array',
         'buffer',
+        'file',
         'date',
         'regexp',
         'map',

package/dist/v1/basics/simpleMath.cjs

@@ -62,7 +62,7 @@ function getSimplePerc(price, percentage) {
 function getAge(timeData = 0, now = null) {
   if (typeof timeData !== 'undefined' && timeData !== null && timeData !== 0) {
     const birthDate = new Date(timeData);
-    if (isNaN(birthDate)) return null;
+    if (Number.isNaN(birthDate.getTime())) return null;
 
     const currentDate = now instanceof Date ? now : new Date();
 

package/dist/v1/basics/simpleMath.mjs

@@ -58,7 +58,7 @@ export function getSimplePerc(price, percentage) {
 export function getAge(timeData = 0, now = null) {
     if (typeof timeData !== 'undefined' && timeData !== null && timeData !== 0) {
         const birthDate = new Date(timeData);
-        if (isNaN(birthDate))
+        if (Number.isNaN(birthDate.getTime()))
             return null;
         const currentDate = now instanceof Date ? now : new Date();
         let age = currentDate.getFullYear() - birthDate.getFullYear();

package/dist/v1/libs/TinyCertCrypto.cjs

@@ -1,9 +1,27 @@
 'use strict';
 
 var fs = require('fs');
-var crypto = require('crypto');
 var buffer = require('buffer');
 
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+
 /**
  * Determines if the environment is a browser.
  *
@@ -33,7 +51,6 @@ class TinyCertCrypto {
    * It supports multi-line content.
    *
    * @type {RegExp}
-   * @private
    */
   #certRegex = /-----BEGIN CERTIFICATE-----([\s\S]+?)-----END CERTIFICATE-----/;
 
@@ -46,7 +63,6 @@ class TinyCertCrypto {
    * It captures the key type (PUBLIC|PRIVATE) and the base64 content.
    *
    * @type {RegExp}
-   * @private
    */
   #keyRegex =
     /-----BEGIN\s+(?:RSA\s+)?(PUBLIC|PRIVATE)\s+KEY-----([\s\S]+?)-----END\s+(?:RSA\s+)?\1\s+KEY-----/;
@@ -114,10 +130,10 @@ class TinyCertCrypto {
    * This method is private and should not be called directly from outside.
    *
    * @returns {Promise<Object>} The loaded `node-forge` module.
-   * @private
    */
   async #fetchNodeForge() {
     if (!this.forge) {
+      // @ts-ignore
       const forge = await import(/* webpackMode: "eager" */ 'node-forge');
       this.forge = forge.default;
     }
@@ -139,7 +155,6 @@ class TinyCertCrypto {
    * Assumes the module has already been loaded.
    *
    * @returns {Object} The `node-forge` module.
-   * @private
    */
   #getNodeForge() {
     return this.forge;
@@ -162,13 +177,12 @@ class TinyCertCrypto {
    * or `'unknown'` if the format is not recognized.
    *
    * @param {string} pemString - The PEM string to inspect.
-   * @returns {'certificate' | 'public_key' | 'private_key' | 'unknown'} The detected PEM type.
-   * @private
+   * @returns {string} The detected PEM type.
    */
   #detectPemType(pemString) {
     if (this.#certRegex.test(pemString)) return 'certificate';
     const keyMatch = this.#keyRegex.exec(pemString);
-    if (keyMatch) return keyMatch[1].toLowerCase() + '_key'; // "public_key" or "private_key"
+    if (keyMatch && typeof keyMatch[1] === 'string') return keyMatch[1].toLowerCase() + '_key'; // "public_key" or "private_key"
     return 'unknown';
   }
 
@@ -178,13 +192,9 @@ class TinyCertCrypto {
    * This method can only be used in Node.js environments. It throws an error if a certificate
    * or key is already loaded into the instance.
    *
-   * @param {Object} subjectFields - An object representing the subject fields of the certificate (e.g., CN, O, C).
+   * @param {Object<string, string>} subjectFields - An object representing the subject fields of the certificate (e.g., CN, O, C).
    * @param {Object} [options={}] - Optional configuration for key and certificate generation.
    * @param {number} [options.modulusLength=2048] - Length of the RSA key in bits.
-   * @param {Object} [options.publicKeyEncoding={ type: 'spki', format: 'pem' }] - Options for public key encoding.
-   * @param {Object} [options.privateKeyEncoding={ type: 'pkcs8', format: 'pem' }] - Options for private key encoding.
-   * @param {string} [options.publicKeyType] - Overrides `publicKeyEncoding.type` if provided.
-   * @param {string} [options.privateKeyType] - Overrides `privateKeyEncoding.type` if provided.
    * @param {number} [options.validityInYears=1] - Number of years the certificate will be valid.
    * @param {number} [options.randomBytesLength=16] - Number of random bytes to use for serial number generation.
    *
@@ -197,34 +207,26 @@ class TinyCertCrypto {
       throw new Error('A certificate is already loaded into the instance.');
 
     // Prepare cert
+    /**  @type {any} */
     const { pki } = await this.#fetchNodeForge();
-    const {
-      modulusLength = 2048,
-      publicKeyEncoding = { type: 'spki', format: 'pem' },
-      privateKeyEncoding = { type: 'pkcs8', format: 'pem' },
-      validityInYears = 1,
-      randomBytesLength = 16,
-    } = options;
 
-    // Value types
-    const publicKeyType = options.publicKeyType || publicKeyEncoding.type;
-    const privateKeyType = options.privateKeyType || privateKeyEncoding.type;
-
-    // Validator
-    if (isBrowser) throw new Error('generateKeyPair can only be used in Node.js environments');
+    /**
+     * @property {number} [modulusLength=2048] - The length of the RSA modulus (in bits). Default is 2048.
+     * @property {number} [validityInYears=1] - The validity period of the key pair in years. Default is 1 year.
+     * @property {number} [randomBytesLength=16] - The length of random bytes used in key generation. Default is 16 bytes.
+     */
+    const { modulusLength = 2048, validityInYears = 1, randomBytesLength = 16 } = options;
 
     // Generate keys
-    const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
-      modulusLength,
-      publicKeyEncoding: { ...publicKeyEncoding, type: publicKeyType },
-      privateKeyEncoding: { ...privateKeyEncoding, type: privateKeyType },
-    });
+    const { publicKey, privateKey } = pki.rsa.generateKeyPair(modulusLength);
+    const encodedPublicKey = pki.publicKeyToPem(publicKey);
+    const encodedPrivateKey = pki.privateKeyToPem(privateKey);
 
     // Get pem files
     const { cert, publicPem, privatePem } = this.#generateCertificate(
       subjectFields,
-      publicKey,
-      privateKey,
+      encodedPublicKey,
+      encodedPrivateKey,
       validityInYears,
       randomBytesLength,
     );
@@ -236,26 +238,33 @@ class TinyCertCrypto {
     this.publicCertPath = 'MEMORY';
     this.privateKeyPath = 'MEMORY';
     this.source = 'memory';
-    this.publicCertBuffer = publicKey;
-    this.privateKeyBuffer = privateKey;
+    this.publicCertBuffer = buffer.Buffer.from(encodedPublicKey);
+    this.privateKeyBuffer = buffer.Buffer.from(encodedPrivateKey);
 
     this.#loadX509Certificate(cert);
-    return { publicKey, privateKey, cert };
+    return { publicKey: encodedPublicKey, privateKey: encodedPrivateKey, cert };
   }
 
+  /**
+   * @typedef {Object} CertificateDetails
+   * @property {string} cert - The certificate in PEM format.
+   * @property {string} publicPem - The public key in PEM format.
+   * @property {string} privatePem - The private key in PEM format.
+   */
+
   /**
    * Generates a self-signed X.509 certificate using the given public and private RSA keys.
    *
    * This method creates a certificate, assigns the subject and issuer fields,
    * sets the validity period, and signs it with the private key.
    *
-   * @param {Object} subject - An object representing the subject/issuer fields (e.g., { CN: 'example.com' }).
+   * @param {Object<string, string>} subject - An object representing the subject/issuer fields (e.g., { CN: 'example.com' }).
    * @param {string} publicKey - The public key in PEM format.
    * @param {string} privateKey - The private key in PEM format.
    * @param {number} validityInYears - Number of years the certificate will remain valid.
    * @param {number} randomBytesLength - Number of random bytes used to generate the serial number.
    *
-   * @returns {Object} An object containing:
+   * @returns {CertificateDetails} An object containing:
    *   - {string} cert: The generated certificate in PEM format.
    *   - {Object} publicPem: The parsed public key object (from node-forge).
    *   - {Object} privatePem: The parsed private key object (from node-forge).
@@ -267,7 +276,9 @@ class TinyCertCrypto {
     const privatePem = pki.privateKeyFromPem(privateKey);
 
     cert.publicKey = publicPem;
-    cert.serialNumber = buffer.Buffer.from(crypto.randomBytes(randomBytesLength)).toString('hex');
+    cert.serialNumber = buffer.Buffer.from(this.forge.random.getBytesSync(randomBytesLength)).toString(
+      'hex',
+    );
     cert.validity.notBefore = new Date();
     cert.validity.notAfter = new Date();
     cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + validityInYears);
@@ -308,8 +319,21 @@ class TinyCertCrypto {
 
     // Load public key
     this.metadata = {};
+    /**  @type {any} */
     const { pki } = await this.#fetchNodeForge();
+
+    /**
+     * Loads the public key from a PEM-encoded certificate or public key.
+     *
+     * @param {string|null} publicPem - The PEM-encoded public key or certificate.
+     * @throws {Error} If the PEM string is not recognized or if the key cannot be parsed.
+     */
     const loadPublicKey = (publicPem) => {
+      if (typeof publicPem !== 'string')
+        throw new Error(
+          'Expected publicPem to be a string containing a PEM-encoded key or certificate.',
+        );
+
       // File type
       const fileType = this.#detectPemType(publicPem);
 
@@ -325,12 +349,29 @@ class TinyCertCrypto {
       else throw new Error('Public key is required to initialize');
     };
 
+    /**
+     * Loads the private key from a PEM-encoded private key.
+     *
+     * @param {string|null} privatePem - The PEM-encoded private key.
+     * @throws {Error} If the PEM string is not recognized or if the key cannot be parsed.
+     */
     const loadPrivateKey = (privatePem) => {
+      if (typeof privatePem !== 'string')
+        throw new Error('Expected privatePem to be a string containing a PEM-encoded private key.');
       const fileType = this.#detectPemType(privatePem);
       if (fileType === 'private_key') this.privateKey = pki.privateKeyFromPem(privatePem);
       else throw new Error('Private key is required to initialize');
     };
 
+    if (typeof this.publicCertPath !== 'string')
+      throw new TypeError(
+        `Expected 'publicCertPath' to be a string, but got ${typeof this.publicCertPath}`,
+      );
+    if (typeof this.privateKeyPath !== 'string')
+      throw new TypeError(
+        `Expected 'privateKeyPath' to be a string, but got ${typeof this.privateKeyPath}`,
+      );
+
     // Nodejs
     if (!isBrowser) {
       const usedPublicBuffer = !!this.publicCertBuffer;
@@ -340,8 +381,10 @@ class TinyCertCrypto {
       const publicPem = usedPublicBuffer
         ? typeof this.publicCertBuffer === 'string'
           ? this.publicCertBuffer
-          : this.publicCertBuffer.toString('utf-8')
-        : fs.readFileSync(this.publicCertPath, 'utf-8');
+          : buffer.Buffer.isBuffer(this.publicCertBuffer)
+            ? this.publicCertBuffer.toString('utf-8')
+            : null
+        : fs__namespace.readFileSync(this.publicCertPath, 'utf-8');
       loadPublicKey(publicPem);
 
       // Private Key
@@ -349,8 +392,10 @@ class TinyCertCrypto {
         const privatePem = usedPrivateBuffer
           ? typeof this.privateKeyBuffer === 'string'
             ? this.privateKeyBuffer
-            : this.privateKeyBuffer.toString('utf-8')
-          : fs.readFileSync(this.privateKeyPath, 'utf-8');
+            : buffer.Buffer.isBuffer(this.privateKeyBuffer)
+              ? this.privateKeyBuffer.toString('utf-8')
+              : null
+          : fs__namespace.readFileSync(this.privateKeyPath, 'utf-8');
 
         loadPrivateKey(privatePem);
       }
@@ -391,7 +436,6 @@ class TinyCertCrypto {
    * This method supports both PEM strings and already-parsed Forge certificate objects.
    * The parsed certificate is saved to `this.publicCert` and its metadata is extracted to `this.metadata`.
    *
-   * @private
    * @param {string|object} certPem - A PEM-encoded certificate string or a `forge.pki.Certificate` object.
    * @throws {Error} If the certificate cannot be parsed or processed.
    */
@@ -401,8 +445,21 @@ class TinyCertCrypto {
       const cert = typeof certPem === 'string' ? pki.certificateFromPem(certPem) : certPem;
       this.publicCert = cert;
 
+      /**
+       * @typedef {Object} Attribute
+       * @property {string} name - The name of the attribute.
+       * @property {string} shortName - The short name of the attribute.
+       * @property {string} value - The value of the attribute.
+       */
+
+      /**
+       * @param {Array<Attribute>} attributes - The list of attributes, each containing `name`, `shortName`, and `value`.
+       * @returns {{names: { [key: string]: string }, shortNames: { [key: string]: string }, raw: string}} The processed data containing the organized attributes.
+       */
       const insertData = (attributes) => {
+        /** @type {{[key: string]: string}} */
         const names = {};
+        /** @type {{[key: string]: string}} */
         const shortNames = {};
         const raw = attributes.map((attr) => `${attr.shortName}=${attr.value}`).join(',');
         for (const item of attributes) {
@@ -420,7 +477,9 @@ class TinyCertCrypto {
         validTo: cert.validity.notAfter,
       };
     } catch (err) {
-      throw new Error('Failed to parse X.509 certificate in browser: ' + err.message);
+      throw new Error(
+        `Failed to parse X.509 certificate in browser: ${err instanceof Error && typeof err.message === 'string' ? err.message : 'Unknown error'}`,
+      );
     }
   }
 

package/dist/v1/libs/TinyCertCrypto.d.mts

@@ -52,14 +52,22 @@ declare class TinyCertCrypto {
         validTo?: undefined;
     } | {
         subject: {
-            names: {};
-            shortNames: {};
-            raw: any;
+            names: {
+                [key: string]: string;
+            };
+            shortNames: {
+                [key: string]: string;
+            };
+            raw: string;
         };
         issuer: {
-            names: {};
-            shortNames: {};
-            raw: any;
+            names: {
+                [key: string]: string;
+            };
+            shortNames: {
+                [key: string]: string;
+            };
+            raw: string;
         };
         serialNumber: any;
         validFrom: any;
@@ -85,25 +93,19 @@ declare class TinyCertCrypto {
      * This method can only be used in Node.js environments. It throws an error if a certificate
      * or key is already loaded into the instance.
      *
-     * @param {Object} subjectFields - An object representing the subject fields of the certificate (e.g., CN, O, C).
+     * @param {Object<string, string>} subjectFields - An object representing the subject fields of the certificate (e.g., CN, O, C).
      * @param {Object} [options={}] - Optional configuration for key and certificate generation.
      * @param {number} [options.modulusLength=2048] - Length of the RSA key in bits.
-     * @param {Object} [options.publicKeyEncoding={ type: 'spki', format: 'pem' }] - Options for public key encoding.
-     * @param {Object} [options.privateKeyEncoding={ type: 'pkcs8', format: 'pem' }] - Options for private key encoding.
-     * @param {string} [options.publicKeyType] - Overrides `publicKeyEncoding.type` if provided.
-     * @param {string} [options.privateKeyType] - Overrides `privateKeyEncoding.type` if provided.
      * @param {number} [options.validityInYears=1] - Number of years the certificate will be valid.
      * @param {number} [options.randomBytesLength=16] - Number of random bytes to use for serial number generation.
      *
      * @returns {Promise<{publicKey: string, privateKey: string, cert: string}>} The generated keys and certificate in PEM format.
      * @throws {Error} If running in a browser or if a cert/key is already loaded.
      */
-    generateX509Cert(subjectFields: Object, options?: {
+    generateX509Cert(subjectFields: {
+        [x: string]: string;
+    }, options?: {
         modulusLength?: number | undefined;
-        publicKeyEncoding?: Object | undefined;
-        privateKeyEncoding?: Object | undefined;
-        publicKeyType?: string | undefined;
-        privateKeyType?: string | undefined;
         validityInYears?: number | undefined;
         randomBytesLength?: number | undefined;
     }): Promise<{