@oxog/string/dist/cjs/index.js

Comprehensive string manipulation utilities with zero dependencies

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.core = exports.Str = exports.removeAccents = void 0;
exports.chain = chain;
// Core exports
__exportStar(require("./core/case"), exports);
__exportStar(require("./core/cleaning"), exports);
__exportStar(require("./core/validation"), exports);
__exportStar(require("./core/analysis"), exports);
__exportStar(require("./core/manipulation"), exports);
__exportStar(require("./core/encoding"), exports);
__exportStar(require("./core/advanced"), exports);
// Type exports
__exportStar(require("./types"), exports);
// Plugin exports
__exportStar(require("./plugins/plugin-interface"), exports);
// Utility exports
__exportStar(require("./utils/unicode"), exports);
__exportStar(require("./utils/algorithms"), exports);
// Re-export removeAccents explicitly to resolve ambiguity
var unicode_1 = require("./utils/unicode");
Object.defineProperty(exports, "removeAccents", { enumerable: true, get: function () { return unicode_1.removeAccents; } });
// Import all functions for APIs
const Case = __importStar(require("./core/case"));
const Cleaning = __importStar(require("./core/cleaning"));
const Validation = __importStar(require("./core/validation"));
const Analysis = __importStar(require("./core/analysis"));
const Manipulation = __importStar(require("./core/manipulation"));
const Encoding = __importStar(require("./core/encoding"));
const Advanced = __importStar(require("./core/advanced"));
const plugin_interface_1 = require("./plugins/plugin-interface");
// Chainable API
class ChainableStringImpl {
    constructor(str) {
        this.str = str;
    }
    // Case transformations
    toCamelCase() {
        return new ChainableStringImpl(Case.toCamelCase(this.str));
    }
    toPascalCase() {
        return new ChainableStringImpl(Case.toPascalCase(this.str));
    }
    toSnakeCase() {
        return new ChainableStringImpl(Case.toSnakeCase(this.str));
    }
    toKebabCase() {
        return new ChainableStringImpl(Case.toKebabCase(this.str));
    }
    toConstantCase() {
        return new ChainableStringImpl(Case.toConstantCase(this.str));
    }
    toTitleCase(locale) {
        return new ChainableStringImpl(Case.toTitleCase(this.str, locale));
    }
    toSentenceCase() {
        return new ChainableStringImpl(Case.toSentenceCase(this.str));
    }
    toLowerCase() {
        return new ChainableStringImpl(this.str.toLowerCase());
    }
    toUpperCase() {
        return new ChainableStringImpl(this.str.toUpperCase());
    }
    // Cleaning
    trim(chars) {
        return new ChainableStringImpl(Cleaning.trim(this.str, chars));
    }
    trimStart(chars) {
        return new ChainableStringImpl(Cleaning.trimStart(this.str, chars));
    }
    trimEnd(chars) {
        return new ChainableStringImpl(Cleaning.trimEnd(this.str, chars));
    }
    removeExtraSpaces() {
        return new ChainableStringImpl(Cleaning.removeExtraSpaces(this.str));
    }
    normalizeWhitespace() {
        return new ChainableStringImpl(Cleaning.normalizeWhitespace(this.str));
    }
    removeNonPrintable() {
        return new ChainableStringImpl(Cleaning.removeNonPrintable(this.str));
    }
    stripHtml() {
        return new ChainableStringImpl(Cleaning.stripHtml(this.str));
    }
    stripAnsi() {
        return new ChainableStringImpl(Cleaning.stripAnsi(this.str));
    }
    removeAccents() {
        return new ChainableStringImpl(Cleaning.removeAccents(this.str));
    }
    // Manipulation
    reverse() {
        return new ChainableStringImpl(Manipulation.reverse(this.str));
    }
    shuffle() {
        return new ChainableStringImpl(Manipulation.shuffle(this.str));
    }
    repeat(count, separator) {
        return new ChainableStringImpl(Manipulation.repeat(this.str, count, separator));
    }
    truncate(length, options) {
        return new ChainableStringImpl(Manipulation.truncate(this.str, length, options));
    }
    pad(length, fillString, type) {
        return new ChainableStringImpl(Manipulation.pad(this.str, length, fillString, type));
    }
    wrap(width, options) {
        return new ChainableStringImpl(Manipulation.wrap(this.str, width, options));
    }
    slugify(options) {
        return new ChainableStringImpl(Manipulation.slugify(this.str, options));
    }
    // Encoding
    encodeBase64() {
        return new ChainableStringImpl(Encoding.encodeBase64(this.str));
    }
    decodeBase64() {
        return new ChainableStringImpl(Encoding.decodeBase64(this.str));
    }
    encodeHex() {
        return new ChainableStringImpl(Encoding.encodeHex(this.str));
    }
    decodeHex() {
        return new ChainableStringImpl(Encoding.decodeHex(this.str));
    }
    encodeHtml() {
        return new ChainableStringImpl(Encoding.encodeHtml(this.str));
    }
    decodeHtml() {
        return new ChainableStringImpl(Encoding.decodeHtml(this.str));
    }
    encodeUri() {
        return new ChainableStringImpl(Encoding.encodeUri(this.str));
    }
    decodeUri() {
        return new ChainableStringImpl(Encoding.decodeUri(this.str));
    }
    // Advanced
    mask(options) {
        return new ChainableStringImpl(Advanced.mask(this.str, options));
    }
    value() {
        return this.str;
    }
}
// Static Class API
class Str {
}
exports.Str = Str;
// Case transformations
Str.toCamelCase = Case.toCamelCase;
Str.toPascalCase = Case.toPascalCase;
Str.toSnakeCase = Case.toSnakeCase;
Str.toKebabCase = Case.toKebabCase;
Str.toConstantCase = Case.toConstantCase;
Str.toTitleCase = Case.toTitleCase;
Str.toSentenceCase = Case.toSentenceCase;
// Cleaning
Str.trim = Cleaning.trim;
Str.trimStart = Cleaning.trimStart;
Str.trimEnd = Cleaning.trimEnd;
Str.removeExtraSpaces = Cleaning.removeExtraSpaces;
Str.normalizeWhitespace = Cleaning.normalizeWhitespace;
Str.removeNonPrintable = Cleaning.removeNonPrintable;
Str.stripHtml = Cleaning.stripHtml;
Str.stripAnsi = Cleaning.stripAnsi;
Str.removeAccents = Cleaning.removeAccents;
// Validation
Str.isEmail = Validation.isEmail;
Str.isUrl = Validation.isUrl;
Str.isUuid = Validation.isUuid;
Str.isHexColor = Validation.isHexColor;
Str.isBase64 = Validation.isBase64;
Str.isJson = Validation.isJson;
Str.isNumeric = Validation.isNumeric;
Str.isAlpha = Validation.isAlpha;
Str.isAlphanumeric = Validation.isAlphanumeric;
Str.isEmpty = Validation.isEmpty;
// Analysis
Str.contains = Analysis.contains;
Str.count = Analysis.count;
Str.indexOfAll = Analysis.indexOfAll;
Str.words = Analysis.words;
Str.chars = Analysis.chars;
Str.codePoints = Analysis.codePoints;
Str.graphemes = Analysis.graphemes;
// Manipulation
Str.reverse = Manipulation.reverse;
Str.shuffle = Manipulation.shuffle;
Str.repeat = Manipulation.repeat;
Str.truncate = Manipulation.truncate;
Str.pad = Manipulation.pad;
Str.wrap = Manipulation.wrap;
Str.slugify = Manipulation.slugify;
// Encoding
Str.encodeBase64 = Encoding.encodeBase64;
Str.decodeBase64 = Encoding.decodeBase64;
Str.encodeHex = Encoding.encodeHex;
Str.decodeHex = Encoding.decodeHex;
Str.encodeHtml = Encoding.encodeHtml;
Str.decodeHtml = Encoding.decodeHtml;
Str.encodeUri = Encoding.encodeUri;
Str.decodeUri = Encoding.decodeUri;
// Advanced
Str.similarity = Advanced.similarity;
Str.fuzzyMatch = Advanced.fuzzyMatch;
Str.soundsLike = Advanced.soundsLike;
Str.findPatterns = Advanced.findPatterns;
Str.isRepeating = Advanced.isRepeating;
Str.extractEmails = Advanced.extractEmails;
Str.extractUrls = Advanced.extractUrls;
Str.extractNumbers = Advanced.extractNumbers;
Str.random = Advanced.random;
Str.generatePronounceable = Advanced.generatePronounceable;
Str.generateFromPattern = Advanced.generateFromPattern;
Str.mask = Advanced.mask;
Str.maskEmail = Advanced.maskEmail;
Str.maskCreditCard = Advanced.maskCreditCard;
Str.hash = Advanced.hash;
Str.toTable = Advanced.toTable;
Str.boxify = Advanced.boxify;
Str.progressBar = Advanced.progressBar;
// Chainable factory function
function chain(str) {
    return new ChainableStringImpl(str);
}
// Plugin core instance
exports.core = new plugin_interface_1.StringCoreImpl();
// Default export for convenience
exports.default = {
    ...Case,
    ...Cleaning,
    ...Validation,
    ...Analysis,
    ...Manipulation,
    ...Encoding,
    ...Advanced,
    Str,
    chain,
    core: exports.core
};