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

Core functionality for Cardog Icons - SVG optimization and processing

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
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/index.ts
var index_exports = {};
__export(index_exports, {
  KNOWN_ACRONYMS: () => KNOWN_ACRONYMS,
  batchOptimizeSvgs: () => batchOptimizeSvgs,
  capitalize: () => capitalize,
  cleanDirectory: () => cleanDirectory,
  ensureDirectoryExists: () => ensureDirectoryExists,
  findSvgFiles: () => findSvgFiles,
  getBasename: () => getBasename,
  optimizeDirectory: () => optimizeDirectory,
  optimizeSvg: () => optimizeSvg,
  processBrandName: () => processBrandName,
  toPascalCase: () => toPascalCase
});
module.exports = __toCommonJS(index_exports);

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

// src/optimize.ts
var import_fs2 = __toESM(require("fs"));
var import_path2 = __toESM(require("path"));
var import_svgo = require("svgo");

// src/utils.ts
var import_fs = __toESM(require("fs"));
var import_path = __toESM(require("path"));
var import_glob = require("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 (!import_fs.default.existsSync(dirPath)) {
    import_fs.default.mkdirSync(dirPath, { recursive: true });
  }
}
function findSvgFiles(directory) {
  return __async(this, null, function* () {
    return (0, import_glob.glob)(`${directory}/**/*.svg`);
  });
}
function cleanDirectory(directory, extensions = [".svg"]) {
  if (!import_fs.default.existsSync(directory)) {
    return;
  }
  const files = import_fs.default.readdirSync(directory);
  for (const file of files) {
    const filePath = import_path.default.join(directory, file);
    const stat = import_fs.default.statSync(filePath);
    if (stat.isDirectory()) {
      cleanDirectory(filePath, extensions);
    } else if (extensions.some((ext) => file.endsWith(ext))) {
      import_fs.default.unlinkSync(filePath);
    }
  }
}
function getBasename(filePath) {
  const basename = import_path.default.basename(filePath);
  const extname = import_path.default.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(import_path2.default.dirname(outputPath));
    const svgContent = import_fs2.default.readFileSync(inputPath, "utf8");
    if (!mergedOptions.optimize) {
      import_fs2.default.writeFileSync(outputPath, svgContent);
      return svgContent;
    }
    try {
      const svgoConfig = {
        multipass: true,
        plugins: ["preset-default", "removeDimensions"]
      };
      const result = (0, import_svgo.optimize)(svgContent, svgoConfig);
      import_fs2.default.writeFileSync(outputPath, result.data);
      return result.data;
    } catch (error) {
      console.error(`Error optimizing SVG ${inputPath}:`, error);
      import_fs2.default.writeFileSync(outputPath, svgContent);
      return svgContent;
    }
  });
}
function optimizeDirectory(_0, _1) {
  return __async(this, arguments, function* (inputDir, outputDir, options = {}) {
    ensureDirectoryExists(outputDir);
    const files = import_fs2.default.readdirSync(inputDir);
    for (const file of files) {
      if (file.endsWith(".svg")) {
        const inputPath = import_path2.default.join(inputDir, file);
        const outputPath = import_path2.default.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 = import_path2.default.basename(filePath);
          const outputPath = import_path2.default.join(outputDir, fileName);
          yield optimizeSvg(filePath, outputPath, options);
          console.log(`Optimized: ${fileName}`);
        }))
      );
    }
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  KNOWN_ACRONYMS,
  batchOptimizeSvgs,
  capitalize,
  cleanDirectory,
  ensureDirectoryExists,
  findSvgFiles,
  getBasename,
  optimizeDirectory,
  optimizeSvg,
  processBrandName,
  toPascalCase
});