@catbee/utils 0.0.8-rc.3 → 1.0.1

package/build/esm/utils/stream.utils.js

@@ -1,209 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2025 Catbee Technologies. https://catbee-utils.npm.hprasath.com/license
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-import { Readable, Transform } from 'stream';
-/**
- * Convert a buffer or string to a readable stream.
- *
- * @param data - Buffer or string to convert
- * @returns Readable stream containing the data
- *
- * @example
- * ```typescript
- * const stream = bufferToStream(Buffer.from('Hello world'));
- * // or
- * const stream = bufferToStream('Hello world');
- * ```
- */
-export function bufferToStream(data) {
-    const readable = new Readable();
-    readable.push(data);
-    readable.push(null); // End of stream
-    return readable;
-}
-/**
- * Convert a readable stream to a buffer.
- *
- * @param stream - Readable stream to convert
- * @returns Promise resolving to a buffer containing all stream data
- *
- * @example
- * ```typescript
- * const buffer = await streamToBuffer(fs.createReadStream('file.txt'));
- * console.log(buffer.toString()); // Contents of file.txt
- * ```
- */
-export async function streamToBuffer(stream) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        stream.on('data', chunk => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
-        stream.on('end', () => resolve(Buffer.concat(chunks)));
-        stream.on('error', reject);
-    });
-}
-/**
- * Convert a readable stream to a string.
- *
- * @param stream - Readable stream to convert
- * @param encoding - Character encoding (default: 'utf8')
- * @returns Promise resolving to a string containing all stream data
- *
- * @example
- * ```typescript
- * const content = await streamToString(fs.createReadStream('file.txt'));
- * console.log(content); // Contents of file.txt as string
- * ```
- */
-export async function streamToString(stream, encoding = 'utf8') {
-    const buffer = await streamToBuffer(stream);
-    return buffer.toString(encoding);
-}
-/**
- * Create a transform stream that limits the rate of data flow.
- *
- * @param bytesPerSecond - Maximum bytes per second
- * @returns Transform stream that throttles data flow
- */
-export function createThrottleStream(bytesPerSecond) {
-    let bytesSent = 0;
-    let startTime = Date.now();
-    return new Transform({
-        transform(chunk, _encoding, callback) {
-            const elapsedSeconds = (Date.now() - startTime) / 1000;
-            const targetBytes = bytesPerSecond * elapsedSeconds;
-            const chunkSize = chunk.length;
-            // If we've sent fewer bytes than our target, just send the chunk
-            if (bytesSent + chunkSize <= targetBytes) {
-                bytesSent += chunkSize;
-                callback(null, chunk);
-                return;
-            }
-            // Otherwise we need to throttle
-            const delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1000;
-            setTimeout(() => {
-                bytesSent += chunkSize;
-                callback(null, chunk);
-            }, delay);
-        }
-    });
-}
-/**
- * Create a transform stream that batches data into chunks of specified size.
- *
- * @param size - Size of each batch (items for object mode, bytes for binary mode)
- * @param options - Stream options
- * @returns Transform stream that batches data
- *
- * @example
- * ```typescript
- * // Batch lines from a file into arrays of 100 lines each
- * createReadStream('large-file.txt')
- *   .pipe(createLineStream())
- *   .pipe(createBatchStream(100))
- *   .on('data', batch => console.log(`Processing batch of ${batch.length} lines`));
- * ```
- */
-export function createBatchStream(size, options = {}) {
-    const objectMode = options.objectMode !== false;
-    let batch = [];
-    let buffers = [];
-    let bufferSize = 0;
-    return new Transform({
-        objectMode,
-        transform(chunk, _encoding, callback) {
-            if (objectMode) {
-                batch.push(chunk);
-                if (batch.length >= size) {
-                    this.push(batch);
-                    batch = [];
-                }
-            }
-            else {
-                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                buffers.push(buffer);
-                bufferSize += buffer.length;
-                // Emit batches of exact size
-                let combined = Buffer.concat(buffers, bufferSize);
-                while (combined.length >= size) {
-                    this.push(combined.slice(0, size));
-                    combined = combined.slice(size);
-                }
-                buffers = combined.length > 0 ? [combined] : [];
-                bufferSize = combined.length;
-            }
-            callback();
-        },
-        flush(callback) {
-            if (objectMode && batch.length > 0) {
-                this.push(batch);
-            }
-            else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
-                let combined = Buffer.concat(buffers, bufferSize);
-                while (combined.length >= size) {
-                    this.push(combined.slice(0, size));
-                    combined = combined.slice(size);
-                }
-                if (combined.length > 0) {
-                    this.push(combined);
-                }
-            }
-            callback();
-        }
-    });
-}
-/**
- * Create a transform stream that splits text data by newlines.
- *
- * @param options - Options for the line stream
- * @returns Transform stream that emits lines
- *
- * @example
- * ```typescript
- * // Process a file line by line
- * createReadStream('file.txt')
- *   .pipe(createLineStream())
- *   .on('data', line => console.log(`Line: ${line}`));
- * ```
- */
-export function createLineStream(options = {}) {
-    const { encoding = 'utf8', includeNewlines = false } = options;
-    let buffer = '';
-    return new Transform({
-        objectMode: true,
-        transform(chunk, _encoding, callback) {
-            const str = buffer + (Buffer.isBuffer(chunk) ? chunk.toString(encoding) : chunk);
-            const lines = str.split(/\r?\n/);
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                this.push(includeNewlines ? line + '\n' : line);
-            }
-            callback();
-        },
-        flush(callback) {
-            if (buffer) {
-                this.push(buffer);
-            }
-            callback();
-        }
-    });
-}

package/build/esm/utils/string.utils.d.ts

@@ -1,92 +0,0 @@
-/**
- * Capitalizes the first character of a string.
- *
- * @param {string} str - The input string.
- * @returns {string} The string with the first character in uppercase.
- */
-export declare function capitalize(str: string): string;
-/**
- * Converts a string to kebab-case (e.g., "FooBar test" → "foo-bar-test").
- *
- * @param {string} str - The input string.
- * @returns {string} The kebab-cased string.
- */
-export declare function toKebabCase(str: string): string;
-/**
- * Converts a kebab-case or snake_case string to camelCase.
- *
- * @param {string} str - The input string.
- * @returns {string} The camelCased string.
- */
-export declare function toCamelCase(str: string): string;
-/**
- * Converts a string to a URL-friendly slug (lowercase, dashes, alphanumeric).
- *
- * @param {string} str - The input string.
- * @returns {string} The slugified string.
- */
-export declare function slugify(str: string): string;
-/**
- * Truncates a string to a specific length, appending '...' if truncated.
- *
- * @param {string} str - The input string.
- * @param {number} len - The maximum length.
- * @returns {string} The truncated string.
- */
-export declare function truncate(str: string, len: number): string;
-/**
- * Converts a string to PascalCase (e.g., "foo-bar" → "FooBar").
- *
- * @param {string} str - The input string.
- * @returns {string} The PascalCased string.
- */
-export declare function toPascalCase(str: string): string;
-/**
- * Converts a string to snake_case (e.g., "FooBar test" → "foo_bar_test").
- *
- * @param {string} str - The input string.
- * @returns {string} The snake_cased string.
- */
-export declare function toSnakeCase(str: string): string;
-/**
- * Masks a string by replacing characters with a mask character.
- * Useful for hiding sensitive information like credit cards or passwords.
- *
- * @param {string} str - The string to mask.
- * @param {number} [visibleStart=0] - Number of characters to show at start.
- * @param {number} [visibleEnd=0] - Number of characters to show at end.
- * @param {string} [maskChar="*"] - Character to use for masking.
- * @returns {string} The masked string.
- */
-export declare function mask(str: string, visibleStart?: number, visibleEnd?: number, maskChar?: string): string;
-/**
- * Removes all HTML tags from a string.
- *
- * @param {string} str - The HTML string to process.
- * @returns {string} The string with HTML tags removed.
- */
-export declare function stripHtml(str: string): string;
-/**
- * Performs case-insensitive string comparison.
- *
- * @param {string} a - First string.
- * @param {string} b - Second string.
- * @returns {boolean} True if the strings are equal ignoring case.
- */
-export declare function equalsIgnoreCase(a: string, b: string): boolean;
-/**
- * Reverses a string.
- *
- * @param {string} str - The string to reverse.
- * @returns {string} The reversed string.
- */
-export declare function reverse(str: string): string;
-/**
- * Counts occurrences of a substring within a string.
- *
- * @param {string} str - The source string.
- * @param {string} substring - The substring to count.
- * @param {boolean} [caseSensitive=true] - Whether to perform case-sensitive counting.
- * @returns {number} Number of occurrences.
- */
-export declare function countOccurrences(str: string, substring: string, caseSensitive?: boolean): number;

package/build/esm/utils/string.utils.js

@@ -1,164 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2025 Catbee Technologies. https://catbee-utils.npm.hprasath.com/license
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-/**
- * Capitalizes the first character of a string.
- *
- * @param {string} str - The input string.
- * @returns {string} The string with the first character in uppercase.
- */
-export function capitalize(str) {
-    return str.length === 0 ? '' : str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
- * Converts a string to kebab-case (e.g., "FooBar test" → "foo-bar-test").
- *
- * @param {string} str - The input string.
- * @returns {string} The kebab-cased string.
- */
-export function toKebabCase(str) {
-    return str
-        .replace(/([a-z])([A-Z])/g, '$1-$2') // camelCase -> camel-Case
-        .replace(/\s+/g, '-') // spaces to dash
-        .replace(/_+/g, '-') // underscores to dash
-        .toLowerCase();
-}
-/**
- * Converts a kebab-case or snake_case string to camelCase.
- *
- * @param {string} str - The input string.
- * @returns {string} The camelCased string.
- */
-export function toCamelCase(str) {
-    return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase());
-}
-/**
- * Converts a string to a URL-friendly slug (lowercase, dashes, alphanumeric).
- *
- * @param {string} str - The input string.
- * @returns {string} The slugified string.
- */
-export function slugify(str) {
-    return str
-        .toLowerCase()
-        .replace(/[^\w\s-]/g, '') // remove non-word
-        .replace(/\s+/g, '-') // spaces to dash
-        .replace(/-+/g, '-') // multiple dashes to one
-        .replace(/^-+|-+$/g, ''); // trim leading/trailing dashes
-}
-/**
- * Truncates a string to a specific length, appending '...' if truncated.
- *
- * @param {string} str - The input string.
- * @param {number} len - The maximum length.
- * @returns {string} The truncated string.
- */
-export function truncate(str, len) {
-    return str.length > len ? str.slice(0, len) + '...' : str;
-}
-/**
- * Converts a string to PascalCase (e.g., "foo-bar" → "FooBar").
- *
- * @param {string} str - The input string.
- * @returns {string} The PascalCased string.
- */
-export function toPascalCase(str) {
-    return capitalize(toCamelCase(str));
-}
-/**
- * Converts a string to snake_case (e.g., "FooBar test" → "foo_bar_test").
- *
- * @param {string} str - The input string.
- * @returns {string} The snake_cased string.
- */
-export function toSnakeCase(str) {
-    return str
-        .trim()
-        .replace(/([a-z])([A-Z])/g, '$1_$2') // camelCase -> camel_Case
-        .replace(/\s+/g, '_') // spaces to underscore
-        .replace(/-+/g, '_') // dashes to underscore
-        .toLowerCase();
-}
-/**
- * Masks a string by replacing characters with a mask character.
- * Useful for hiding sensitive information like credit cards or passwords.
- *
- * @param {string} str - The string to mask.
- * @param {number} [visibleStart=0] - Number of characters to show at start.
- * @param {number} [visibleEnd=0] - Number of characters to show at end.
- * @param {string} [maskChar="*"] - Character to use for masking.
- * @returns {string} The masked string.
- */
-export function mask(str, visibleStart = 0, visibleEnd = 0, maskChar = '*') {
-    if (!str || str.length === 0)
-        return '';
-    if (visibleStart >= str.length)
-        return str;
-    const start = str.slice(0, visibleStart);
-    const end = visibleEnd > 0 ? str.slice(-visibleEnd) : '';
-    const masked = maskChar.repeat(Math.max(0, str.length - visibleStart - visibleEnd));
-    return start + masked + end;
-}
-/**
- * Removes all HTML tags from a string.
- *
- * @param {string} str - The HTML string to process.
- * @returns {string} The string with HTML tags removed.
- */
-export function stripHtml(str) {
-    return str.replace(/<[^>]*>/g, '');
-}
-/**
- * Performs case-insensitive string comparison.
- *
- * @param {string} a - First string.
- * @param {string} b - Second string.
- * @returns {boolean} True if the strings are equal ignoring case.
- */
-export function equalsIgnoreCase(a, b) {
-    return a.toLowerCase() === b.toLowerCase();
-}
-/**
- * Reverses a string.
- *
- * @param {string} str - The string to reverse.
- * @returns {string} The reversed string.
- */
-export function reverse(str) {
-    return str.split('').reverse().join('');
-}
-/**
- * Counts occurrences of a substring within a string.
- *
- * @param {string} str - The source string.
- * @param {string} substring - The substring to count.
- * @param {boolean} [caseSensitive=true] - Whether to perform case-sensitive counting.
- * @returns {number} Number of occurrences.
- */
-export function countOccurrences(str, substring, caseSensitive = true) {
-    if (!caseSensitive) {
-        str = str.toLowerCase();
-        substring = substring.toLowerCase();
-    }
-    return str.split(substring).length - 1;
-}

package/build/esm/utils/type.utils.d.ts

@@ -1,89 +0,0 @@
-/**
- * Check if a value is of a specific primitive type.
- *
- * @param value - Value to check
- * @param type - Type to check against
- * @returns Whether the value is of the specified type
- *
- * @example
- * ```typescript
- * isPrimitiveType('hello', 'string'); // true
- * isPrimitiveType(42, 'number'); // true
- * isPrimitiveType(true, 'boolean'); // true
- * isPrimitiveType(null, 'null'); // true
- * isPrimitiveType(undefined, 'undefined'); // true
- * isPrimitiveType({}, 'object'); // true
- * isPrimitiveType([], 'array'); // true
- * ```
- */
-export declare function isPrimitiveType(value: unknown, type: 'string' | 'number' | 'boolean' | 'symbol' | 'bigint' | 'function' | 'object' | 'array' | 'null' | 'undefined'): boolean;
-/**
- * Get the primitive type of a value as a string.
- *
- * @param value - Value to get the type of
- * @returns String representing the type
- *
- * @example
- * ```typescript
- * getTypeOf('hello'); // 'string'
- * getTypeOf(42); // 'number'
- * getTypeOf([]); // 'array'
- * getTypeOf(null); // 'null'
- * ```
- */
-export declare function getTypeOf(value: unknown): string;
-/**
- * Type guard for checking if a value is an array of a specific type.
- *
- * @param value - Value to check
- * @param itemTypeGuard - Function that checks if items are of the expected type
- * @returns True if the value is an array with items of the expected type
- *
- * @example
- * ```typescript
- * isArrayOf([1, 2, 3], (item): item is number => typeof item === 'number'); // true
- * isArrayOf(['a', 'b', 'c'], (item): item is string => typeof item === 'string'); // true
- * isArrayOf([1, '2', 3], (item): item is number => typeof item === 'number'); // false
- * ```
- */
-export declare function isArrayOf<T>(value: unknown, itemTypeGuard: (item: unknown) => item is T): value is T[];
-/**
- * Convert a value to a string.
- *
- * @param value - Value to convert
- * @param defaultValue - Default value if conversion fails
- * @returns String representation of the value
- */
-export declare function toStr(value: unknown, defaultValue?: string): string;
-/**
- * Convert a value to a number.
- *
- * @param value - Value to convert
- * @param defaultValue - Default value if conversion fails
- * @returns Numeric representation of the value
- */
-export declare function toNum(value: unknown, defaultValue?: number): number;
-/**
- * Convert a value to a boolean.
- *
- * @param value - Value to convert
- * @param defaultValue - Default value if conversion fails
- * @returns Boolean representation of the value
- */
-export declare function toBool(value: unknown, defaultValue?: boolean): boolean;
-/**
- * Ensure a value matches the expected type, or provide a default.
- *
- * @param value - Value to check
- * @param expectedType - Expected primitive type
- * @param defaultValue - Default value to use if type doesn't match
- * @returns The value if it matches the type, otherwise the default
- *
- * @example
- * ```typescript
- * ensureType(42, 'number', 0); // 42
- * ensureType('42', 'number', 0); // 0
- * ensureType(undefined, 'string', 'default'); // 'default'
- * ```
- */
-export declare function ensureType<T>(value: unknown, expectedType: string, defaultValue: T): T;