qrcode-generator-sabai/dist/index.mjs

qrcode-generator-sabai is a Node.js package designed to simplify QR code generation from various payloads to images. It offers ease of use and extensive customization options.

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/lib/util.ts
import fs from "fs";
import QRCode from "qrcode";
import sharp from "sharp";
var _Util = class _Util {
};
_Util.generatePngQR = (payload, size = 400, ecl = "H", fileName, filePath) => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    const result = new Promise((resolve, reject) => {
      QRCode.toFile(
        `${filePath}/${fileName}.png`,
        [{ data: payload }],
        { width: size, margin: 0.5, type: "png", errorCorrectionLevel: ecl },
        (err, url) => {
          if (err) {
            reject(err);
          } else {
            resolve(url);
          }
        }
      );
    });
    return true;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.generatePngQRWithLogo = (payload, size = 400, ecl = "H", fileName, filePath, logoPath) => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    const qrBuffer = yield QRCode.toBuffer(
      [{ data: payload }],
      { width: size, margin: 0.5, type: "png", errorCorrectionLevel: ecl }
    );
    const qrImage = sharp(qrBuffer).resize(size, size);
    const logoImage = sharp(logoPath).resize(Math.floor(size / 4), Math.floor(size / 4), { fit: "contain", background: { r: 255, g: 255, b: 255, alpha: 0 } }).toFormat("png");
    const compositeImage = yield qrImage.composite([{ input: yield logoImage.toBuffer(), gravity: "center" }]).png().toBuffer();
    fs.writeFileSync(`${filePath}/${fileName}.png`, compositeImage);
    return true;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.generateSvgQR = (payload, size = 400, ecl = "H", fileName, filePath) => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    if (filePath && fileName) {
      const result = new Promise((resolve, reject) => {
        QRCode.toFile(
          `${filePath}/${fileName}.svg`,
          [{ data: payload }],
          { width: size, margin: 0.5, type: "svg", errorCorrectionLevel: ecl },
          (err, url) => {
            if (err) {
              reject(err);
            } else {
              resolve(url);
            }
          }
        );
      });
      return true;
    } else {
      const result = new Promise((resolve, reject) => {
        QRCode.toString([{ data: payload }], { type: "svg", width: size, margin: 0.5, errorCorrectionLevel: ecl }, (err, url) => {
          if (err) {
            reject(err);
          } else {
            if (url) {
              resolve(url);
            } else {
              reject(new Error("QRCode generation failed"));
            }
          }
        });
      });
      return result;
    }
  } catch (error) {
    throw new Error(error);
  }
});
_Util.generateSvgQRWithLogo = (payload, size = 400, ecl = "H", fileName, filePath, logoPath) => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    const qrBuffer = yield QRCode.toBuffer(payload, {
      width: size,
      margin: 0.5,
      errorCorrectionLevel: ecl
    });
    const qrImage = sharp(qrBuffer).resize(size, size);
    const logoSize = Math.floor(size / 4);
    const logoImage = sharp(logoPath).resize(logoSize, logoSize, { fit: "contain", background: { r: 255, g: 255, b: 255, alpha: 0 } }).toFormat("png");
    const compositeImage = yield qrImage.composite([{ input: yield logoImage.toBuffer(), gravity: "center" }]).png().toBuffer();
    const base64Data = `data:image/png;base64,${compositeImage.toString("base64")}`;
    const svgData = `<svg xmlns="http://www.w3.org/2000/svg" width="400" height="400" viewBox="0 0 400 400">
                <image href="${base64Data}" width="400" height="400"/>
            </svg>`;
    if (filePath && fileName) {
      fs.writeFileSync(`${filePath}/${fileName}.svg`, svgData, "utf-8");
      return true;
    }
    return svgData;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.generateSvgQRFile = (payload, size = 400, ecl = "H", fileName, filePath) => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    const result = new Promise((resolve, reject) => {
      QRCode.toFile(
        `${filePath}/${fileName}.svg`,
        [{ data: payload }],
        { width: size, margin: 0.5, type: "svg", errorCorrectionLevel: ecl },
        (err, url) => {
          if (err) {
            reject(err);
          } else {
            resolve(url);
          }
        }
      );
    });
    return true;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.generateSvgQRWithLogoFile = (payload, size = 400, ecl = "H", fileName, filePath, logoPath) => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    const qrBuffer = yield QRCode.toBuffer(payload, {
      width: size,
      margin: 0.5,
      errorCorrectionLevel: ecl
    });
    const qrImage = sharp(qrBuffer).resize(size, size);
    const logoSize = Math.floor(size / 4);
    const logoImage = sharp(logoPath).resize(logoSize, logoSize, { fit: "contain", background: { r: 255, g: 255, b: 255, alpha: 0 } }).toFormat("png");
    const compositeImage = yield qrImage.composite([{ input: yield logoImage.toBuffer(), gravity: "center" }]).png().toBuffer();
    const base64Data = `data:image/png;base64,${compositeImage.toString("base64")}`;
    const svgData = `<svg xmlns="http://www.w3.org/2000/svg" width="400" height="400" viewBox="0 0 400 400">
                <image href="${base64Data}" width="400" height="400"/>
            </svg>`;
    fs.writeFileSync(`${filePath}/${fileName}.svg`, svgData, "utf-8");
    return true;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.generateBase64QR = (payload, size = 400, ecl = "H") => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    const result = new Promise((resolve, reject) => {
      QRCode.toDataURL([{ data: payload }], { width: size, margin: 0.5, errorCorrectionLevel: ecl }, (err, url) => {
        if (err) {
          reject(err);
        } else {
          if (url) {
            resolve(url);
          } else {
            reject(new Error("QRCode generation failed"));
          }
        }
      });
    });
    return result;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.generateBase64QrWithLogo = (payload, size = 400, ecl = "H", logoPath) => __async(_Util, null, function* () {
  try {
    size = parseInt(String(size));
    const qrBuffer = yield QRCode.toBuffer(payload, {
      width: size,
      margin: 0.5,
      errorCorrectionLevel: ecl
    });
    const qrImage = sharp(qrBuffer).resize(size, size);
    const logoSize = Math.floor(size / 4);
    const logoImage = sharp(logoPath).resize(logoSize, logoSize, { fit: "contain", background: { r: 255, g: 255, b: 255, alpha: 0 } }).toFormat("png");
    const compositeImage = yield qrImage.composite([{ input: yield logoImage.toBuffer(), gravity: "center" }]).png().toBuffer();
    return `data:image/png;base64,${compositeImage.toString("base64")}`;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.base64ToImage = (base64Data, fileName, filePath) => __async(_Util, null, function* () {
  try {
    const data = base64Data.replace(/^data:image\/\w+;base64,/, "");
    const buf = Buffer.from(data, "base64");
    fs.writeFileSync(`${filePath}/${fileName}`, buf);
    return true;
  } catch (error) {
    throw new Error(error);
  }
});
_Util.base64ToSvg = (base64Data, fileName, filePath) => __async(_Util, null, function* () {
  try {
    const svgData = `<svg xmlns="http://www.w3.org/2000/svg" width="400" height="400" viewBox="0 0 400 400">
                <image href="${base64Data}" width="400" height="400"/>
            </svg>`;
    fs.writeFileSync(`${filePath}/${fileName}`, svgData, "utf-8");
    return true;
  } catch (error) {
    throw new Error(error);
  }
});
var Util = _Util;

// src/lib/init.ts
var Init = class {
  static png(payload, size = 400, ecl, fileName, filePath) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generatePngQR(payload, size, ecl, fileName, filePath);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
  static pngWithLogo(payload, size = 400, ecl, fileName, filePath, logoPath) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generatePngQRWithLogo(payload, size, ecl, fileName, filePath, logoPath);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
  static base64(payload, size = 400, ecl) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generateBase64QR(payload, size, ecl);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
  static base64WithLogo(payload, size = 400, ecl, logoPath) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generateBase64QrWithLogo(payload, size, ecl, logoPath);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
  static svg(payload, size = 400, ecl, fileName, filePath) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generateSvgQR(payload, size, ecl, fileName, filePath);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
  static svgWithLogo(payload, size = 400, ecl, fileName, filePath, logoPath) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generateSvgQRWithLogo(payload, size, ecl, fileName, filePath, logoPath);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
  static svgFile(payload, size = 400, ecl, fileName, filePath) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generateSvgQRFile(payload, size, ecl, fileName, filePath);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
  static svgWithLogoFile(payload, size = 400, ecl, fileName, filePath, logoPath) {
    return __async(this, null, function* () {
      try {
        const result = yield Util.generateSvgQRWithLogoFile(payload, size, ecl, fileName, filePath, logoPath);
        return result;
      } catch (error) {
        throw new Error(error);
      }
    });
  }
};

// src/index.ts
var QR = class {
  constructor() {
  }
  static validateLogoPath(logoPath) {
    if (!logoPath)
      return null;
    if (!/\.(png|svg)$/i.test(logoPath)) {
      throw new Error(`Invalid logo file type "${logoPath}". Only .png or .svg files are allowed.`);
    }
    return logoPath;
  }
  static generate(payload, options) {
    const { format = "png", size = 400, errorCorrection = "M", filePath, fileName, logoPath } = options;
    const validLogoPath = this.validateLogoPath(logoPath != null ? logoPath : "");
    switch (format) {
      case "png":
        return logoPath ? Init.pngWithLogo(payload, size, errorCorrection, fileName, filePath, validLogoPath) : Init.png(payload, size, errorCorrection, fileName, filePath);
      case "svg":
        return logoPath ? Init.svgWithLogo(payload, size, errorCorrection, fileName, filePath, validLogoPath) : Init.svg(payload, size, errorCorrection, fileName, filePath);
      case "base64":
        return logoPath ? Init.base64WithLogo(payload, size, errorCorrection, validLogoPath) : Init.base64(payload, size, errorCorrection);
      default:
        throw new Error("Invalid format. Supported formats: png, svg, base64.");
    }
  }
};
var src_default = QR;
export {
  QR,
  src_default as default
};
//# sourceMappingURL=index.mjs.map