@cardog-icons/core/dist/index.mjs

Core functionality for Cardog Icons - SVG optimization and processing

var __defProp = Object.defineProperty;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/types.ts
var KNOWN_ACRONYMS = [
  "BMW",
  "RAM",
  "MB",
  "BYD",
  "GMC",
  "US",
  "UK",
  "EU"
];

// src/optimize.ts
import fs2 from "fs";
import path2 from "path";
import { optimize as svgoOptimize } from "svgo";

// src/utils.ts
import fs from "fs";
import path from "path";
import { glob } from "glob";
function toPascalCase(input) {
  const spaceSeparated = input.replace(/[^a-zA-Z0-9]/g, " ").trim();
  const parts = spaceSeparated.split(" ").filter((part) => part.length > 0);
  return parts.map((part) => {
    for (const acronym of KNOWN_ACRONYMS) {
      if (part.toUpperCase() === acronym) {
        return acronym;
      }
      const upperPart = part.toUpperCase();
      if (upperPart.startsWith(acronym)) {
        const index = upperPart.indexOf(acronym);
        const before = index > 0 ? capitalize(part.substring(0, index)) : "";
        const after = index + acronym.length < part.length ? capitalize(part.substring(index + acronym.length)) : "";
        return before + acronym + after;
      }
    }
    return capitalize(part);
  }).join("");
}
function capitalize(input) {
  if (!input || input.length === 0) return input;
  return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
}
function ensureDirectoryExists(dirPath) {
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath, { recursive: true });
  }
}
function findSvgFiles(directory) {
  return __async(this, null, function* () {
    return glob(`${directory}/**/*.svg`);
  });
}
function cleanDirectory(directory, extensions = [".svg"]) {
  if (!fs.existsSync(directory)) {
    return;
  }
  const files = fs.readdirSync(directory);
  for (const file of files) {
    const filePath = path.join(directory, file);
    const stat = fs.statSync(filePath);
    if (stat.isDirectory()) {
      cleanDirectory(filePath, extensions);
    } else if (extensions.some((ext) => file.endsWith(ext))) {
      fs.unlinkSync(filePath);
    }
  }
}
function getBasename(filePath) {
  const basename = path.basename(filePath);
  const extname = path.extname(basename);
  return basename.substring(0, basename.length - extname.length);
}
function processBrandName(brandName) {
  const nameParts = brandName.split(" ");
  let processedName = "";
  for (const part of nameParts) {
    let isAcronym = false;
    for (const acronym of KNOWN_ACRONYMS) {
      if (part.toUpperCase() === acronym) {
        processedName += acronym;
        isAcronym = true;
        break;
      }
    }
    if (!isAcronym) {
      processedName += capitalize(part);
    }
  }
  return processedName;
}

// src/optimize.ts
var defaultOptions = {
  floatPrecision: 2,
  plugins: ["preset-default"],
  multipass: true
};
function optimizeSvg(_0, _1) {
  return __async(this, arguments, function* (inputPath, outputPath, options = {}) {
    const mergedOptions = __spreadValues(__spreadValues({}, defaultOptions), options);
    ensureDirectoryExists(path2.dirname(outputPath));
    const svgContent = fs2.readFileSync(inputPath, "utf8");
    if (!mergedOptions.optimize) {
      fs2.writeFileSync(outputPath, svgContent);
      return svgContent;
    }
    try {
      const svgoConfig = {
        multipass: true,
        plugins: ["preset-default", "removeDimensions"]
      };
      const result = svgoOptimize(svgContent, svgoConfig);
      fs2.writeFileSync(outputPath, result.data);
      return result.data;
    } catch (error) {
      console.error(`Error optimizing SVG ${inputPath}:`, error);
      fs2.writeFileSync(outputPath, svgContent);
      return svgContent;
    }
  });
}
function optimizeDirectory(_0, _1) {
  return __async(this, arguments, function* (inputDir, outputDir, options = {}) {
    ensureDirectoryExists(outputDir);
    const files = fs2.readdirSync(inputDir);
    for (const file of files) {
      if (file.endsWith(".svg")) {
        const inputPath = path2.join(inputDir, file);
        const outputPath = path2.join(outputDir, file);
        yield optimizeSvg(inputPath, outputPath, options);
      }
    }
  });
}
function batchOptimizeSvgs(_0, _1) {
  return __async(this, arguments, function* (filePaths, outputDir, options = {}, batchSize = 10) {
    ensureDirectoryExists(outputDir);
    console.log(
      `Processing ${filePaths.length} SVG files in batches of ${batchSize}...`
    );
    for (let i = 0; i < filePaths.length; i += batchSize) {
      const batch = filePaths.slice(i, i + batchSize);
      console.log(
        `Processing batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(filePaths.length / batchSize)}...`
      );
      yield Promise.all(
        batch.map((filePath) => __async(this, null, function* () {
          const fileName = path2.basename(filePath);
          const outputPath = path2.join(outputDir, fileName);
          yield optimizeSvg(filePath, outputPath, options);
          console.log(`Optimized: ${fileName}`);
        }))
      );
    }
  });
}
export {
  KNOWN_ACRONYMS,
  batchOptimizeSvgs,
  capitalize,
  cleanDirectory,
  ensureDirectoryExists,
  findSvgFiles,
  getBasename,
  optimizeDirectory,
  optimizeSvg,
  processBrandName,
  toPascalCase
};