uncase/dist/is.cjs

Wrapper of change-case to create case converter, validator and etc.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/is.ts
var is_exports = {};
__export(is_exports, {
  isCamelCase: () => isCamelCase,
  isCapitalCase: () => isCapitalCase,
  isConstantCase: () => isConstantCase,
  isDotCase: () => isDotCase,
  isKebabCase: () => isKebabCase,
  isNoCase: () => isNoCase,
  isPascalCase: () => isPascalCase,
  isPascalSnakeCase: () => isPascalSnakeCase,
  isPathCase: () => isPathCase,
  isSentenceCase: () => isSentenceCase,
  isSnakeCase: () => isSnakeCase,
  isTrainCase: () => isTrainCase
});
module.exports = __toCommonJS(is_exports);

// src/core.ts
var import_change_case = require("change-case");
var convertersMap = {
  camelCase: import_change_case.camelCase,
  capitalCase: import_change_case.capitalCase,
  "Capital Case": import_change_case.capitalCase,
  CONSTANT_CASE: import_change_case.constantCase,
  constantCase: import_change_case.constantCase,
  "dot.case": import_change_case.dotCase,
  dotCase: import_change_case.dotCase,
  "kebab-case": import_change_case.kebabCase,
  kebabCase: import_change_case.kebabCase,
  noCase: import_change_case.noCase,
  "no case": import_change_case.noCase,
  Pascal_Snake_Case: import_change_case.pascalSnakeCase,
  pascalCase: import_change_case.pascalCase,
  PascalCase: import_change_case.pascalCase,
  pascalSnakeCase: import_change_case.pascalSnakeCase,
  "path/case": import_change_case.pathCase,
  pathCase: import_change_case.pathCase,
  sentenceCase: import_change_case.sentenceCase,
  "Sentence case": import_change_case.sentenceCase,
  snake_case: import_change_case.snakeCase,
  snakeCase: import_change_case.snakeCase,
  "Train-Case": import_change_case.trainCase,
  trainCase: import_change_case.trainCase
};
function getCaseConverter(caseType, options = {}) {
  const convert = convertersMap[caseType];
  return (input) => {
    const output = convert(input, options);
    const changed = output !== input;
    return {
      changed,
      input,
      output
    };
  };
}

// src/is.ts
function createCaseValidator(caseType) {
  const convert = getCaseConverter(caseType);
  return (input) => {
    if (!isNonEmptyString(input)) return false;
    return !convert(input).changed;
  };
}
function isNonEmptyString(value) {
  return isString(value) && value.length > 0;
}
function isString(value) {
  return typeof value === "string";
}
var isCamelCase = (input) => createCaseValidator("camelCase")(input);
var isCapitalCase = (input) => createCaseValidator("capitalCase")(input);
var isConstantCase = (input) => createCaseValidator("constantCase")(input);
var isDotCase = (input) => createCaseValidator("dotCase")(input);
var isKebabCase = (input) => createCaseValidator("kebabCase")(input);
var isNoCase = (input) => createCaseValidator("noCase")(input);
var isPascalCase = (input) => createCaseValidator("pascalCase")(input);
var isPascalSnakeCase = (input) => createCaseValidator("pascalSnakeCase")(input);
var isPathCase = (input) => createCaseValidator("pathCase")(input);
var isSentenceCase = (input) => createCaseValidator("sentenceCase")(input);
var isSnakeCase = (input) => createCaseValidator("snakeCase")(input);
var isTrainCase = (input) => createCaseValidator("trainCase")(input);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  isCamelCase,
  isCapitalCase,
  isConstantCase,
  isDotCase,
  isKebabCase,
  isNoCase,
  isPascalCase,
  isPascalSnakeCase,
  isPathCase,
  isSentenceCase,
  isSnakeCase,
  isTrainCase
});