advanced-js-kit
Version:
Modern TypeScript utility library with tree-shaking support - Array, String, Number, Network, Sleep, and JWT utilities for JavaScript and TypeScript projects
263 lines (255 loc) • 8.61 kB
JavaScript
// src/universal/array/index.ts
function chunk(array, size) {
if (size <= 0) {
throw new Error("Chunk size must be greater than 0");
}
if (array.length === 0) {
return [];
}
const chunks = [];
for (let i = 0; i < array.length; i += size) {
chunks.push(array.slice(i, i + size));
}
return chunks;
}
// src/universal/string/capitalize.ts
function capitalize(str) {
if (typeof str !== "string") {
throw new Error("Input must be a string");
}
if (str.length === 0) {
return str;
}
return str.charAt(0).toUpperCase() + str.slice(1);
}
function capitalizeWords(str) {
if (typeof str !== "string") {
throw new Error("Input must be a string");
}
return str.replace(/\b\w/g, (char) => char.toUpperCase());
}
function convertCamelToNormalCapitalized(camelCaseString) {
const words = camelCaseString.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[\s_]+/);
const capitalizedWords = words.map(
(word) => word.charAt(0).toUpperCase() + word.slice(1)
);
const normalCapitalizedString = capitalizedWords.join(" ");
return normalCapitalizedString;
}
// src/universal/string/truncate.ts
function truncateText({
text,
maxLength = 10,
suffix = "..."
}) {
return text.length > maxLength ? text.substring(0, maxLength) + suffix : text;
}
// src/universal/string/index.ts
function randomStringWithFixedLength(length) {
if (!Number.isInteger(length) || length <= 0) {
throw new Error("Length must be a positive integer.");
}
return Array.from({ length }, () => Math.random().toString(36)[2]).join("");
}
// src/universal/number/index.ts
function clamp(number, lower, upper) {
if (typeof number !== "number" || typeof lower !== "number" || typeof upper !== "number") {
throw new Error("All arguments must be numbers");
}
if (lower > upper) {
throw new Error("Lower bound must be less than or equal to upper bound");
}
return Math.min(Math.max(number, lower), upper);
}
function inRange(number, lower, upper) {
if (typeof number !== "number" || typeof lower !== "number" || typeof upper !== "number") {
throw new Error("All arguments must be numbers");
}
if (lower > upper) {
throw new Error("Lower bound must be less than or equal to upper bound");
}
return number >= lower && number <= upper;
}
var convertToInt = (data) => {
if (isNaN(data)) {
throw new Error("Invalid input: not a number");
}
if (data === null || data === void 0) {
throw new Error("Invalid input: null or undefined");
}
if (typeof data === "number") {
data = data + "";
}
return +parseInt(data);
};
var convertToTwoDecimalInt = (data) => {
if (isNaN(data)) {
throw new Error("Invalid input: not a number");
}
if (data === null || data === void 0) {
throw new Error("Invalid input: null or undefined");
}
if (typeof data === "number") {
data = data + "";
}
return +parseFloat(data).toFixed(2);
};
var randomNumberWithFixedLength = (length) => {
if (length <= 0 || !Number.isInteger(length)) {
throw new Error("Length must be a positive integer.");
}
return Math.floor(
Math.pow(10, length - 1) + Math.random() * (9 * Math.pow(10, length - 1))
);
};
// src/universal/sleep/index.ts
var sleep = (params) => {
return new Promise((resolve, reject) => {
let delayMs = 0;
try {
if (!params || Object.keys(params).length === 0) {
throw new Error("Sleep parameters cannot be empty");
}
if (params.until?.unixTimestamp) {
const now = Date.now();
const targetTime = params.until.unixTimestamp * 1e3;
delayMs = Math.max(0, targetTime - now);
if (delayMs === 0) {
resolve();
return;
}
} else if (params.random) {
if (params.random.milliseconds) {
const { min, max } = params.random.milliseconds;
if (min < 0 || max < 0 || min > max) {
throw new Error("Invalid random milliseconds range");
}
delayMs = Math.random() * (max - min) + min;
} else if (params.random.seconds) {
const { min, max } = params.random.seconds;
if (min < 0 || max < 0 || min > max) {
throw new Error("Invalid random seconds range");
}
delayMs = (Math.random() * (max - min) + min) * 1e3;
} else if (params.random.minutes) {
const { min, max } = params.random.minutes;
if (min < 0 || max < 0 || min > max) {
throw new Error("Invalid random minutes range");
}
delayMs = (Math.random() * (max - min) + min) * 60 * 1e3;
} else {
throw new Error("Random delay type must be specified (milliseconds, seconds, or minutes)");
}
} else {
if (params.milliseconds !== void 0) {
if (params.milliseconds < 0) {
throw new Error("Milliseconds cannot be negative");
}
delayMs += params.milliseconds;
}
if (params.seconds !== void 0) {
if (params.seconds < 0) {
throw new Error("Seconds cannot be negative");
}
delayMs += params.seconds * 1e3;
}
if (params.minutes !== void 0) {
if (params.minutes < 0) {
throw new Error("Minutes cannot be negative");
}
delayMs += params.minutes * 60 * 1e3;
}
if (delayMs === 0 && !params.milliseconds && !params.seconds && !params.minutes) {
throw new Error("At least one delay parameter must be specified");
}
}
const MAX_DELAY = 2147483647;
if (delayMs > MAX_DELAY) {
throw new Error(`Delay too large. Maximum delay is ${MAX_DELAY}ms`);
}
setTimeout(resolve, Math.floor(delayMs));
} catch (error) {
reject(error);
}
});
};
var sleepMs = (ms) => {
return sleep({ milliseconds: ms });
};
var sleepSeconds = (seconds) => {
return sleep({ seconds });
};
var sleepMinutes = (minutes) => {
return sleep({ minutes });
};
var sleepUntil = (unixTimestamp) => {
return sleep({ until: { unixTimestamp } });
};
// src/universal/time/index.ts
function convertToSeconds(options = {}) {
const {
seconds = 0,
minutes = 0,
hours = 0,
days = 0,
months = 0,
years = 0
} = options;
const SECONDS_PER_MINUTE = 60;
const SECONDS_PER_HOUR = 60 * 60;
const SECONDS_PER_DAY = 60 * 60 * 24;
const SECONDS_PER_MONTH = 60 * 60 * 24 * 30;
const SECONDS_PER_YEAR = 60 * 60 * 24 * 365;
return seconds + minutes * SECONDS_PER_MINUTE + hours * SECONDS_PER_HOUR + days * SECONDS_PER_DAY + months * SECONDS_PER_MONTH + years * SECONDS_PER_YEAR;
}
var getUnixTimestampMs = () => {
return Date.now();
};
var getUnixTimestamp = () => {
return Math.floor(getUnixTimestampMs() / 1e3);
};
// src/universal/utils/index.ts
function isNodeEnvironment() {
return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
}
function isBrowserEnvironment() {
return typeof window !== "undefined" && typeof document !== "undefined";
}
function isWebWorkerEnvironment() {
return typeof globalThis.importScripts === "function" && typeof window === "undefined";
}
function getEnvironment() {
if (isNodeEnvironment()) return "node";
if (isBrowserEnvironment()) return "browser";
if (isWebWorkerEnvironment()) return "webworker";
return "unknown";
}
var EnvironmentError = class extends Error {
constructor(message, requiredEnvironment, currentEnvironment) {
super(message);
this.requiredEnvironment = requiredEnvironment;
this.currentEnvironment = currentEnvironment;
this.name = "EnvironmentError";
}
};
function assertNodeEnvironment() {
if (!isNodeEnvironment()) {
throw new EnvironmentError(
"This functionality requires Node.js environment",
"node",
getEnvironment()
);
}
}
function assertBrowserEnvironment() {
if (!isBrowserEnvironment()) {
throw new EnvironmentError(
"This functionality requires browser environment",
"browser",
getEnvironment()
);
}
}
export { EnvironmentError, assertBrowserEnvironment, assertNodeEnvironment, capitalize, capitalizeWords, chunk, clamp, convertCamelToNormalCapitalized, convertToInt, convertToSeconds, convertToTwoDecimalInt, getEnvironment, getUnixTimestamp, getUnixTimestampMs, inRange, isBrowserEnvironment, isNodeEnvironment, isWebWorkerEnvironment, randomNumberWithFixedLength, randomStringWithFixedLength, sleep, sleepMinutes, sleepMs, sleepSeconds, sleepUntil, truncateText };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map