ayiin 2.0.17 → 2.0.19

package/dist/bin/cli.cjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+'use strict';
+
+var version = "2.0.19";
+var pkg = {
+	version: version};
+
+// CLI entry point
+console.log("Welcome to ayiin CLI!");
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    console.log("Usage: ayiin <command>");
+    process.exit(0);
+}
+switch(args[0]){
+    case "hello":
+        console.log("Hai Ayiin, CLI sudah jalan!");
+        break;
+    case "version":
+        console.log(`ayiin CLI v${pkg.version}`);
+        break;
+    case "help":
+        console.log("Available commands: hello, version, help");
+        break;
+    default:
+        console.log(`Unknown command: ${args[0]}`);
+}

package/{bin → dist/bin}/cli.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const package_json_1 = __importDefault(require("../../package.json"));
+var version = "2.0.19";
+var pkg = {
+	version: version};
+
 // CLI entry point
 console.log("Welcome to ayiin CLI!");
 const args = process.argv.slice(2);
@@ -12,12 +10,12 @@ if (args.length === 0) {
     console.log("Usage: ayiin <command>");
     process.exit(0);
 }
-switch (args[0]) {
+switch(args[0]){
     case "hello":
         console.log("Hai Ayiin, CLI sudah jalan!");
         break;
     case "version":
-        console.log(`ayiin CLI v${package_json_1.default.version}`);
+        console.log(`ayiin CLI v${pkg.version}`);
         break;
     case "help":
         console.log("Available commands: hello, version, help");

package/dist/cjs/index.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var _package = require('./package.json.cjs');
+var methods_index = require('./methods/index.cjs');
+
+class Ayiin extends methods_index {
+    version = _package.default.version;
+    constructor(){
+        super();
+    }
+}
+
+module.exports = Ayiin;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/dist/cjs/methods/crypt.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var crypto = require('crypto');
+
+class Crypt {
+    /**
+   * Performs Base encryption and decryption.
+   * @param {string | Buffer} input - The input data to be encrypted or decrypted.
+   * @param {string} key - The encryption/decryption key.
+   * @returns {Buffer} - The encrypted or decrypted data as a Buffer.
+   */ baseCrypt = (input, key)=>{
+        const inputBuffer = Buffer.from(input, "ascii");
+        const keyBuffer = Buffer.from(key, "ascii");
+        const resultBuffer = Buffer.alloc(inputBuffer.length);
+        for(let i = 0; i < inputBuffer.length; i++){
+            resultBuffer[i] = inputBuffer[i] ^ keyBuffer[i % keyBuffer.length];
+        }
+        return resultBuffer;
+    };
+    /**
+   * Encrypts a plaintext message using the given key.
+   * @param {string} text - The plaintext message to be encrypted.
+   * @param {string} key - The encryption key.
+   * @returns {string} - The encrypted data in Hex format.
+   */ encrypt = (text, key, bufferEncoding = "base64")=>{
+        const encryptedBuffer = this.baseCrypt(text, key);
+        return encryptedBuffer.toString(bufferEncoding);
+    };
+    /**
+   * Decrypts an encrypted message using the given key.
+   * @param {string} encrypted - The encrypted data in Hex format.
+   * @param {string} key - The decryption key.
+   * @returns {string} - The decrypted plaintext message.
+   */ decrypt = (encrypted, key, bufferEncoding = "base64")=>{
+        const encryptedBuffer = Buffer.from(encrypted, bufferEncoding);
+        const decryptedBuffer = this.baseCrypt(encryptedBuffer, key);
+        return decryptedBuffer.toString("ascii");
+    };
+    /**
+   * Converts a Hex string to its corresponding ASCII representation.
+   * @param {string} hexString - The Hex string to be converted.
+   * @returns {string} - The ASCII representation of the Hex string.
+   */ hexToAscii = (hexString)=>{
+        const hexBuffer = Buffer.from(hexString, "hex");
+        return hexBuffer.toString("ascii");
+    };
+    /**
+   * Converts an ASCII string to its corresponding Hex representation.
+   * @param {string} asciiString - The ASCII string to be converted.
+   * @returns {string} - The Hex representation of the ASCII string.
+   */ asciiToHex = (asciiString)=>{
+        const asciiBuffer = Buffer.from(asciiString, "ascii");
+        return asciiBuffer.toString("hex");
+    };
+    md5 = (data, encoding)=>{
+        if (!encoding) encoding = "hex";
+        let hasho = crypto.createHash("md5").update(data).digest(encoding);
+        return hasho;
+    };
+}
+
+module.exports = Crypt;
+//# sourceMappingURL=crypt.cjs.map

package/dist/cjs/methods/crypt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypt.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/index.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var methods_crypt = require('./crypt.cjs');
+var methods_tools = require('./tools.cjs');
+var methods_response = require('./response.cjs');
+
+class Methods {
+}
+// copy instance properties
+Object.assign(Methods.prototype, new methods_tools());
+Object.assign(Methods.prototype, new methods_crypt());
+Object.assign(Methods.prototype, new methods_response());
+
+module.exports = Methods;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/methods/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/dist/cjs/methods/response.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+class ResponseApi {
+    success = ({ caption, data, code })=>{
+        code = code ? Number(String(code) + "7400") : 2007400;
+        return {
+            responseCode: code,
+            responseSuccess: true,
+            responseMessage: `[Success] - ${caption}`,
+            responseData: data
+        };
+    };
+    badRequest = ({ caption, title, data })=>{
+        return {
+            responseCode: 4007400,
+            responseSuccess: false,
+            responseMessage: `[${title ? title : "Bad Request"}] - ${caption}`,
+            responseData: data
+        };
+    };
+    invalidFields = ({ caption, data })=>{
+        return {
+            responseCode: 4007401,
+            responseSuccess: false,
+            responseMessage: `[Invalid Fields] - ${caption}`,
+            responseData: data
+        };
+    };
+    notFound = ({ caption, data })=>{
+        return {
+            responseCode: 4047400,
+            responseSuccess: false,
+            responseMessage: `[Not Found] - ${caption}`,
+            responseData: data
+        };
+    };
+    unauthorized = ({ caption, data })=>{
+        return {
+            responseCode: 4017400,
+            responseSuccess: false,
+            responseMessage: `[Unauthorized] - ${caption}`,
+            responseData: data
+        };
+    };
+    internalServer = ({ caption, data })=>{
+        return {
+            responseCode: 5007400,
+            responseSuccess: false,
+            responseMessage: `[Internal Server Error] - ${caption}`,
+            responseData: data
+        };
+    };
+}
+
+module.exports = ResponseApi;
+//# sourceMappingURL=response.cjs.map

package/dist/cjs/methods/response.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/methods/tools.cjs

@@ -0,0 +1,162 @@
+'use strict';
+
+class Tools {
+    /**
+   * Format money ke string sesuai locale
+   * @memberof Tools
+   * @param {number | string} amount - jumlah uang
+   * @param {Intl.LocalesArgument} locales - default "id-ID"
+   * @param {Intl.NumberFormatOptions} options - default currency IDR
+   * @returns {string} string
+   */ formatMoney = (amount, locales = "id-ID", options = {
+        style: "currency",
+        currency: "IDR",
+        minimumFractionDigits: 0
+    })=>{
+        return new Intl.NumberFormat(locales, options).format(Number(amount));
+    };
+    /**
+   * Generate unique ID dengan pilihan tipe
+   * @param {"number"|"string"|"mixed"} type - tipe ID (angka, string, atau campuran)
+   * @param {number} length - panjang ID (default 8)
+   * @returns {string} ID unik acak
+   */ uniqueId = ({ type = "mixed", length = 8, prefix })=>{
+        let chars;
+        switch(type){
+            case "number":
+                chars = "0123456789";
+                break;
+            case "string":
+                chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+                break;
+            default:
+                chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        }
+        let id = "";
+        for(let i = 0; i < Number(length); i++){
+            id += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return prefix ? prefix + id : id;
+    };
+    /**
+   * Generate UUID v4 sederhana
+   * @returns {string}
+   */ randomUuid = ()=>{
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c)=>{
+            const r = Math.random() * 16 | 0;
+            const v = c === "x" ? r : r & 0x3 | 0x8;
+            return v.toString(16);
+        });
+    };
+    /**
+   * Pick a random from array
+   * @param {T[]} array
+   * @memberof Tools
+   * @returns {T} item acak dari array
+   */ randomItem = (array)=>{
+        return array[Math.floor(Math.random() * array.length)];
+    };
+    /**
+   * Ambil beberapa item acak unik dari array
+   * @param {T[]} array
+   * @param {number} count - jumlah item
+   * @returns {T[]} array item acak unik dari array
+   */ randomMany = (array, count)=>{
+        const copy = [
+            ...array
+        ];
+        for(let i = copy.length - 1; i > 0; i--){
+            const j = Math.floor(Math.random() * (i + 1));
+            [copy[i], copy[j]] = [
+                copy[j],
+                copy[i]
+            ];
+        }
+        return copy.slice(0, Number(count));
+    };
+    /**
+   * Validasi apakah string adalah email
+   * @param {string} str
+   * @returns {boolean} true jika string adalah email, false jika bukan
+   */ isEmail = (str)=>/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
+    /**
+   * Validasi apakah string adalah URL
+   * @param {string} str
+   * @returns {boolean} true jika string adalah URL, false jika bukan
+   */ isUrl = (str)=>{
+        try {
+            new URL(str);
+            return true;
+        } catch  {
+            return false;
+        }
+    };
+    /**
+   * Format tanggal ke string sesuai locale
+   * @param {Date} date
+   * @param {Intl.LocalesArgument} locales - default "id-ID"
+   * @returns {string} string
+   */ formatDate = (date, locales = "id-ID")=>new Intl.DateTimeFormat(locales, {
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit"
+        }).format(date);
+    /**
+   * Hitung waktu relatif (misalnya "5 menit lalu")
+   * @param {Date} date
+   * @returns {string} string
+   */ timeAgo = (date)=>{
+        const diff = Date.now() - date.getTime();
+        const seconds = Math.floor(diff / 1000);
+        if (seconds < 60) return `${seconds} detik lalu`;
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) return `${minutes} menit lalu`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24) return `${hours} jam lalu`;
+        const days = Math.floor(hours / 24);
+        return `${days} hari lalu`;
+    };
+    /**
+   * Convert string menjadi camelCase
+   * @param {string} input - string yang akan diubah
+   * @returns {string} camelCase string
+   */ toCamelCase = (input)=>{
+        return input.toLowerCase().replace(/[-_\s]+(.)?/g, (_, chr)=>chr ? chr.toUpperCase() : "");
+    };
+    /**
+   * Capitalize string (huruf pertama jadi kapital)
+   * @param {string} input - string yang akan diubah
+   * @returns {string} string dengan huruf pertama kapital
+   */ capitalize = (input)=>{
+        if (!input) return "";
+        return input.charAt(0).toUpperCase() + input.slice(1);
+    };
+    slugify = (str)=>{
+        return str.toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "");
+    };
+    deepClone = (obj)=>{
+        return JSON.parse(JSON.stringify(obj));
+    };
+    isEmptyObject = (obj)=>{
+        return Object.keys(obj).length === 0;
+    };
+    sleep = (ms)=>{
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    };
+    retry = async (fn, retries = 3)=>{
+        let error;
+        for(let i = 0; i < retries; i++){
+            try {
+                return await fn();
+            } catch (err) {
+                error = err;
+            }
+        }
+        throw error;
+    };
+}
+
+module.exports = Tools;
+//# sourceMappingURL=tools.cjs.map

package/dist/cjs/methods/tools.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/package.json.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var version = "2.0.19";
+var pkg = {
+	version: version};
+
+exports.default = pkg;
+exports.version = version;
+//# sourceMappingURL=package.json.cjs.map

package/dist/cjs/package.json.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.json.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+import pkg from './package.json.js';
+import Methods from './methods/index.js';
+
+class Ayiin extends Methods {
+    version = pkg.version;
+    constructor(){
+        super();
+    }
+}
+
+export { Ayiin as default };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/esm/methods/crypt.js

@@ -0,0 +1,61 @@
+import crypto from 'crypto';
+
+class Crypt {
+    /**
+   * Performs Base encryption and decryption.
+   * @param {string | Buffer} input - The input data to be encrypted or decrypted.
+   * @param {string} key - The encryption/decryption key.
+   * @returns {Buffer} - The encrypted or decrypted data as a Buffer.
+   */ baseCrypt = (input, key)=>{
+        const inputBuffer = Buffer.from(input, "ascii");
+        const keyBuffer = Buffer.from(key, "ascii");
+        const resultBuffer = Buffer.alloc(inputBuffer.length);
+        for(let i = 0; i < inputBuffer.length; i++){
+            resultBuffer[i] = inputBuffer[i] ^ keyBuffer[i % keyBuffer.length];
+        }
+        return resultBuffer;
+    };
+    /**
+   * Encrypts a plaintext message using the given key.
+   * @param {string} text - The plaintext message to be encrypted.
+   * @param {string} key - The encryption key.
+   * @returns {string} - The encrypted data in Hex format.
+   */ encrypt = (text, key, bufferEncoding = "base64")=>{
+        const encryptedBuffer = this.baseCrypt(text, key);
+        return encryptedBuffer.toString(bufferEncoding);
+    };
+    /**
+   * Decrypts an encrypted message using the given key.
+   * @param {string} encrypted - The encrypted data in Hex format.
+   * @param {string} key - The decryption key.
+   * @returns {string} - The decrypted plaintext message.
+   */ decrypt = (encrypted, key, bufferEncoding = "base64")=>{
+        const encryptedBuffer = Buffer.from(encrypted, bufferEncoding);
+        const decryptedBuffer = this.baseCrypt(encryptedBuffer, key);
+        return decryptedBuffer.toString("ascii");
+    };
+    /**
+   * Converts a Hex string to its corresponding ASCII representation.
+   * @param {string} hexString - The Hex string to be converted.
+   * @returns {string} - The ASCII representation of the Hex string.
+   */ hexToAscii = (hexString)=>{
+        const hexBuffer = Buffer.from(hexString, "hex");
+        return hexBuffer.toString("ascii");
+    };
+    /**
+   * Converts an ASCII string to its corresponding Hex representation.
+   * @param {string} asciiString - The ASCII string to be converted.
+   * @returns {string} - The Hex representation of the ASCII string.
+   */ asciiToHex = (asciiString)=>{
+        const asciiBuffer = Buffer.from(asciiString, "ascii");
+        return asciiBuffer.toString("hex");
+    };
+    md5 = (data, encoding)=>{
+        if (!encoding) encoding = "hex";
+        let hasho = crypto.createHash("md5").update(data).digest(encoding);
+        return hasho;
+    };
+}
+
+export { Crypt as default };
+//# sourceMappingURL=crypt.js.map

package/dist/esm/methods/crypt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypt.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/methods/index.js

@@ -0,0 +1,13 @@
+import Crypt from './crypt.js';
+import Tools from './tools.js';
+import ResponseApi from './response.js';
+
+class Methods {
+}
+// copy instance properties
+Object.assign(Methods.prototype, new Tools());
+Object.assign(Methods.prototype, new Crypt());
+Object.assign(Methods.prototype, new ResponseApi());
+
+export { Methods as default };
+//# sourceMappingURL=index.js.map

package/dist/esm/methods/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/{methods → dist/esm/methods}/response.js

@@ -1,54 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 class ResponseApi {
-    success = ({ caption, data, code, }) => {
+    success = ({ caption, data, code })=>{
         code = code ? Number(String(code) + "7400") : 2007400;
         return {
             responseCode: code,
             responseSuccess: true,
             responseMessage: `[Success] - ${caption}`,
-            responseData: data,
+            responseData: data
         };
     };
-    badRequest = ({ caption, title, data, }) => {
+    badRequest = ({ caption, title, data })=>{
         return {
             responseCode: 4007400,
             responseSuccess: false,
             responseMessage: `[${title ? title : "Bad Request"}] - ${caption}`,
-            responseData: data,
+            responseData: data
         };
     };
-    invalidFields = ({ caption, data }) => {
+    invalidFields = ({ caption, data })=>{
         return {
             responseCode: 4007401,
             responseSuccess: false,
             responseMessage: `[Invalid Fields] - ${caption}`,
-            responseData: data,
+            responseData: data
         };
     };
-    notFound = ({ caption, data }) => {
+    notFound = ({ caption, data })=>{
         return {
             responseCode: 4047400,
             responseSuccess: false,
             responseMessage: `[Not Found] - ${caption}`,
-            responseData: data,
+            responseData: data
         };
     };
-    unauthorized = ({ caption, data }) => {
+    unauthorized = ({ caption, data })=>{
         return {
             responseCode: 4017400,
             responseSuccess: false,
             responseMessage: `[Unauthorized] - ${caption}`,
-            responseData: data,
+            responseData: data
         };
     };
-    internalServer = ({ caption, data }) => {
+    internalServer = ({ caption, data })=>{
         return {
             responseCode: 5007400,
             responseSuccess: false,
             responseMessage: `[Internal Server Error] - ${caption}`,
-            responseData: data,
+            responseData: data
         };
     };
 }
-exports.default = ResponseApi;
+
+export { ResponseApi as default };
+//# sourceMappingURL=response.js.map

package/dist/esm/methods/response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/methods/tools.js

@@ -0,0 +1,160 @@
+class Tools {
+    /**
+   * Format money ke string sesuai locale
+   * @memberof Tools
+   * @param {number | string} amount - jumlah uang
+   * @param {Intl.LocalesArgument} locales - default "id-ID"
+   * @param {Intl.NumberFormatOptions} options - default currency IDR
+   * @returns {string} string
+   */ formatMoney = (amount, locales = "id-ID", options = {
+        style: "currency",
+        currency: "IDR",
+        minimumFractionDigits: 0
+    })=>{
+        return new Intl.NumberFormat(locales, options).format(Number(amount));
+    };
+    /**
+   * Generate unique ID dengan pilihan tipe
+   * @param {"number"|"string"|"mixed"} type - tipe ID (angka, string, atau campuran)
+   * @param {number} length - panjang ID (default 8)
+   * @returns {string} ID unik acak
+   */ uniqueId = ({ type = "mixed", length = 8, prefix })=>{
+        let chars;
+        switch(type){
+            case "number":
+                chars = "0123456789";
+                break;
+            case "string":
+                chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+                break;
+            default:
+                chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        }
+        let id = "";
+        for(let i = 0; i < Number(length); i++){
+            id += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return prefix ? prefix + id : id;
+    };
+    /**
+   * Generate UUID v4 sederhana
+   * @returns {string}
+   */ randomUuid = ()=>{
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c)=>{
+            const r = Math.random() * 16 | 0;
+            const v = c === "x" ? r : r & 0x3 | 0x8;
+            return v.toString(16);
+        });
+    };
+    /**
+   * Pick a random from array
+   * @param {T[]} array
+   * @memberof Tools
+   * @returns {T} item acak dari array
+   */ randomItem = (array)=>{
+        return array[Math.floor(Math.random() * array.length)];
+    };
+    /**
+   * Ambil beberapa item acak unik dari array
+   * @param {T[]} array
+   * @param {number} count - jumlah item
+   * @returns {T[]} array item acak unik dari array
+   */ randomMany = (array, count)=>{
+        const copy = [
+            ...array
+        ];
+        for(let i = copy.length - 1; i > 0; i--){
+            const j = Math.floor(Math.random() * (i + 1));
+            [copy[i], copy[j]] = [
+                copy[j],
+                copy[i]
+            ];
+        }
+        return copy.slice(0, Number(count));
+    };
+    /**
+   * Validasi apakah string adalah email
+   * @param {string} str
+   * @returns {boolean} true jika string adalah email, false jika bukan
+   */ isEmail = (str)=>/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
+    /**
+   * Validasi apakah string adalah URL
+   * @param {string} str
+   * @returns {boolean} true jika string adalah URL, false jika bukan
+   */ isUrl = (str)=>{
+        try {
+            new URL(str);
+            return true;
+        } catch  {
+            return false;
+        }
+    };
+    /**
+   * Format tanggal ke string sesuai locale
+   * @param {Date} date
+   * @param {Intl.LocalesArgument} locales - default "id-ID"
+   * @returns {string} string
+   */ formatDate = (date, locales = "id-ID")=>new Intl.DateTimeFormat(locales, {
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit"
+        }).format(date);
+    /**
+   * Hitung waktu relatif (misalnya "5 menit lalu")
+   * @param {Date} date
+   * @returns {string} string
+   */ timeAgo = (date)=>{
+        const diff = Date.now() - date.getTime();
+        const seconds = Math.floor(diff / 1000);
+        if (seconds < 60) return `${seconds} detik lalu`;
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) return `${minutes} menit lalu`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24) return `${hours} jam lalu`;
+        const days = Math.floor(hours / 24);
+        return `${days} hari lalu`;
+    };
+    /**
+   * Convert string menjadi camelCase
+   * @param {string} input - string yang akan diubah
+   * @returns {string} camelCase string
+   */ toCamelCase = (input)=>{
+        return input.toLowerCase().replace(/[-_\s]+(.)?/g, (_, chr)=>chr ? chr.toUpperCase() : "");
+    };
+    /**
+   * Capitalize string (huruf pertama jadi kapital)
+   * @param {string} input - string yang akan diubah
+   * @returns {string} string dengan huruf pertama kapital
+   */ capitalize = (input)=>{
+        if (!input) return "";
+        return input.charAt(0).toUpperCase() + input.slice(1);
+    };
+    slugify = (str)=>{
+        return str.toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "");
+    };
+    deepClone = (obj)=>{
+        return JSON.parse(JSON.stringify(obj));
+    };
+    isEmptyObject = (obj)=>{
+        return Object.keys(obj).length === 0;
+    };
+    sleep = (ms)=>{
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    };
+    retry = async (fn, retries = 3)=>{
+        let error;
+        for(let i = 0; i < retries; i++){
+            try {
+                return await fn();
+            } catch (err) {
+                error = err;
+            }
+        }
+        throw error;
+    };
+}
+
+export { Tools as default };
+//# sourceMappingURL=tools.js.map

package/dist/esm/methods/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/package.json.js

@@ -0,0 +1,6 @@
+var version = "2.0.19";
+var pkg = {
+	version: version};
+
+export { pkg as default, version };
+//# sourceMappingURL=package.json.js.map

package/dist/esm/package.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/{methods → dist/methods}/response.d.ts

@@ -2,7 +2,7 @@ declare class ResponseApi {
     success: ({ caption, data, code, }: {
         caption: string;
         data: any;
-        code?: number;
+        code?: number | string;
     }) => {
         responseCode: number;
         responseSuccess: boolean;

package/{methods → dist/methods}/tools.d.ts

@@ -2,12 +2,12 @@ declare class Tools {
     /**
      * Format money ke string sesuai locale
      * @memberof Tools
-     * @param {number} amount - jumlah uang
+     * @param {number | string} amount - jumlah uang
      * @param {Intl.LocalesArgument} locales - default "id-ID"
      * @param {Intl.NumberFormatOptions} options - default currency IDR
      * @returns {string} string
      */
-    formatMoney: (amount: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions) => string;
+    formatMoney: (amount: number | string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions) => string;
     /**
      * Generate unique ID dengan pilihan tipe
      * @param {"number"|"string"|"mixed"} type - tipe ID (angka, string, atau campuran)
@@ -16,7 +16,7 @@ declare class Tools {
      */
     uniqueId: ({ type, length, prefix, }: {
         type?: "number" | "string" | "mixed";
-        length?: number;
+        length?: number | string;
         prefix?: string;
     }) => string;
     /**
@@ -37,7 +37,7 @@ declare class Tools {
      * @param {number} count - jumlah item
      * @returns {T[]} array item acak unik dari array
      */
-    randomMany: <T>(array: T[], count: number) => T[];
+    randomMany: <T>(array: T[], count: number | string) => T[];
     /**
      * Validasi apakah string adalah email
      * @param {string} str
@@ -75,5 +75,10 @@ declare class Tools {
      * @returns {string} string dengan huruf pertama kapital
      */
     capitalize: (input: string) => string;
+    slugify: (str: string) => string;
+    deepClone: <T>(obj: T) => T;
+    isEmptyObject: (obj: object) => boolean;
+    sleep: (ms: number) => Promise<void>;
+    retry: <T>(fn: () => Promise<T>, retries?: number) => Promise<T>;
 }
 export default Tools;

package/package.json

@@ -1,13 +1,25 @@
 {
   "name": "ayiin",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "description": "Library Pribadi Yang Gak Ada Isinya",
-  "main": "index.js",
   "bin": {
-    "ayiin": "./bin/cli.js"
+    "ayiin": "./dist/bin/cli.js"
+  },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/esm/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
   "scripts": {
-    "build": "tsc"
+    "build:esm": "tsc",
+    "build:cjs": "rollup -c rollup.config.mjs",
+    "build": "bun run build:esm && bun run build:cjs"
   },
   "repository": {
     "type": "git",
@@ -22,7 +34,11 @@
   ],
   "license": "GPL-3.0-only",
   "devDependencies": {
+    "@rollup/plugin-json": "^6.1.0",
+    "@types/bun": "^1.4.1",
     "@types/node": "^26.3.0",
+    "rollup": "^4.63.1",
+    "rollup-plugin-swc3": "^0.12.1",
     "typescript": "^7"
   }
 }

package/index.js

@@ -1,15 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-ignore
-const package_json_1 = __importDefault(require("./package.json"));
-const methods_1 = __importDefault(require("./methods"));
-class Ayiin extends methods_1.default {
-    version = package_json_1.default.version;
-    constructor() {
-        super();
-    }
-}
-exports.default = Ayiin;

package/methods/crypt.js

@@ -1,69 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = __importDefault(require("crypto"));
-class Crypt {
-    /**
-     * Performs Base encryption and decryption.
-     * @param {string | Buffer} input - The input data to be encrypted or decrypted.
-     * @param {string} key - The encryption/decryption key.
-     * @returns {Buffer} - The encrypted or decrypted data as a Buffer.
-     */
-    baseCrypt = (input, key) => {
-        const inputBuffer = Buffer.from(input, "ascii");
-        const keyBuffer = Buffer.from(key, "ascii");
-        const resultBuffer = Buffer.alloc(inputBuffer.length);
-        for (let i = 0; i < inputBuffer.length; i++) {
-            resultBuffer[i] = inputBuffer[i] ^ keyBuffer[i % keyBuffer.length];
-        }
-        return resultBuffer;
-    };
-    /**
-     * Encrypts a plaintext message using the given key.
-     * @param {string} text - The plaintext message to be encrypted.
-     * @param {string} key - The encryption key.
-     * @returns {string} - The encrypted data in Hex format.
-     */
-    encrypt = (text, key, bufferEncoding = "base64") => {
-        const encryptedBuffer = this.baseCrypt(text, key);
-        return encryptedBuffer.toString(bufferEncoding);
-    };
-    /**
-     * Decrypts an encrypted message using the given key.
-     * @param {string} encrypted - The encrypted data in Hex format.
-     * @param {string} key - The decryption key.
-     * @returns {string} - The decrypted plaintext message.
-     */
-    decrypt = (encrypted, key, bufferEncoding = "base64") => {
-        const encryptedBuffer = Buffer.from(encrypted, bufferEncoding);
-        const decryptedBuffer = this.baseCrypt(encryptedBuffer, key);
-        return decryptedBuffer.toString("ascii");
-    };
-    /**
-     * Converts a Hex string to its corresponding ASCII representation.
-     * @param {string} hexString - The Hex string to be converted.
-     * @returns {string} - The ASCII representation of the Hex string.
-     */
-    hexToAscii = (hexString) => {
-        const hexBuffer = Buffer.from(hexString, "hex");
-        return hexBuffer.toString("ascii");
-    };
-    /**
-     * Converts an ASCII string to its corresponding Hex representation.
-     * @param {string} asciiString - The ASCII string to be converted.
-     * @returns {string} - The Hex representation of the ASCII string.
-     */
-    asciiToHex = (asciiString) => {
-        const asciiBuffer = Buffer.from(asciiString, "ascii");
-        return asciiBuffer.toString("hex");
-    };
-    md5 = (data, encoding) => {
-        if (!encoding)
-            encoding = "hex";
-        let hasho = crypto_1.default.createHash("md5").update(data).digest(encoding);
-        return hasho;
-    };
-}
-exports.default = Crypt;

package/methods/index.js

@@ -1,15 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypt_1 = __importDefault(require("./crypt"));
-const tools_1 = __importDefault(require("./tools"));
-const response_1 = __importDefault(require("./response"));
-class Methods {
-}
-// copy instance properties
-Object.assign(Methods.prototype, new tools_1.default());
-Object.assign(Methods.prototype, new crypt_1.default());
-Object.assign(Methods.prototype, new response_1.default());
-exports.default = Methods;

package/methods/tools.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Tools {
-    /**
-     * Format money ke string sesuai locale
-     * @memberof Tools
-     * @param {number} amount - jumlah uang
-     * @param {Intl.LocalesArgument} locales - default "id-ID"
-     * @param {Intl.NumberFormatOptions} options - default currency IDR
-     * @returns {string} string
-     */
-    formatMoney = (amount, locales = "id-ID", options = {
-        style: "currency",
-        currency: "IDR",
-        minimumFractionDigits: 0,
-    }) => {
-        return new Intl.NumberFormat(locales, options).format(amount);
-    };
-    /**
-     * Generate unique ID dengan pilihan tipe
-     * @param {"number"|"string"|"mixed"} type - tipe ID (angka, string, atau campuran)
-     * @param {number} length - panjang ID (default 8)
-     * @returns {string} ID unik acak
-     */
-    uniqueId = ({ type = "mixed", length = 8, prefix, }) => {
-        let chars;
-        switch (type) {
-            case "number":
-                chars = "0123456789";
-                break;
-            case "string":
-                chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-                break;
-            default:
-                chars =
-                    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-        }
-        let id = "";
-        for (let i = 0; i < length; i++) {
-            id += chars[Math.floor(Math.random() * chars.length)];
-        }
-        return prefix ? prefix + id : id;
-    };
-    /**
-     * Generate UUID v4 sederhana
-     * @returns {string}
-     */
-    randomUuid = () => {
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-            const r = (Math.random() * 16) | 0;
-            const v = c === "x" ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    };
-    /**
-     * Pick a random from array
-     * @param {T[]} array
-     * @memberof Tools
-     * @returns {T} item acak dari array
-     */
-    randomItem = (array) => {
-        return array[Math.floor(Math.random() * array.length)];
-    };
-    /**
-     * Ambil beberapa item acak unik dari array
-     * @param {T[]} array
-     * @param {number} count - jumlah item
-     * @returns {T[]} array item acak unik dari array
-     */
-    randomMany = (array, count) => {
-        const copy = [...array];
-        for (let i = copy.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [copy[i], copy[j]] = [copy[j], copy[i]];
-        }
-        return copy.slice(0, count);
-    };
-    /**
-     * Validasi apakah string adalah email
-     * @param {string} str
-     * @returns {boolean} true jika string adalah email, false jika bukan
-     */
-    isEmail = (str) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
-    /**
-     * Validasi apakah string adalah URL
-     * @param {string} str
-     * @returns {boolean} true jika string adalah URL, false jika bukan
-     */
-    isUrl = (str) => {
-        try {
-            new URL(str);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    /**
-     * Format tanggal ke string sesuai locale
-     * @param {Date} date
-     * @param {Intl.LocalesArgument} locales - default "id-ID"
-     * @returns {string} string
-     */
-    formatDate = (date, locales = "id-ID") => new Intl.DateTimeFormat(locales, {
-        year: "numeric",
-        month: "long",
-        day: "numeric",
-        hour: "2-digit",
-        minute: "2-digit",
-    }).format(date);
-    /**
-     * Hitung waktu relatif (misalnya "5 menit lalu")
-     * @param {Date} date
-     * @returns {string} string
-     */
-    timeAgo = (date) => {
-        const diff = Date.now() - date.getTime();
-        const seconds = Math.floor(diff / 1000);
-        if (seconds < 60)
-            return `${seconds} detik lalu`;
-        const minutes = Math.floor(seconds / 60);
-        if (minutes < 60)
-            return `${minutes} menit lalu`;
-        const hours = Math.floor(minutes / 60);
-        if (hours < 24)
-            return `${hours} jam lalu`;
-        const days = Math.floor(hours / 24);
-        return `${days} hari lalu`;
-    };
-    /**
-     * Convert string menjadi camelCase
-     * @param {string} input - string yang akan diubah
-     * @returns {string} camelCase string
-     */
-    toCamelCase = (input) => {
-        return input
-            .toLowerCase()
-            .replace(/[-_\s]+(.)?/g, (_, chr) => (chr ? chr.toUpperCase() : ""));
-    };
-    /**
-     * Capitalize string (huruf pertama jadi kapital)
-     * @param {string} input - string yang akan diubah
-     * @returns {string} string dengan huruf pertama kapital
-     */
-    capitalize = (input) => {
-        if (!input)
-            return "";
-        return input.charAt(0).toUpperCase() + input.slice(1);
-    };
-}
-exports.default = Tools;