fastqr 1.0.1

data/bindings/nodejs/binding.gyp

@@ -0,0 +1,38 @@
+{
+  "targets": [
+    {
+      "target_name": "fastqr",
+      "sources": [
+        "fastqr_node.cpp",
+        "../../src/fastqr.cpp"
+      ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "../../include"
+      ],
+      "libraries": [
+        "-lqrencode",
+        "-lvips"
+      ],
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "cflags_cc": [ "-std=c++14" ],
+      "xcode_settings": {
+        "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+        "CLANG_CXX_LIBRARY": "libc++",
+        "MACOSX_DEPLOYMENT_TARGET": "10.15",
+        "OTHER_CFLAGS": [
+          "-std=c++14"
+        ]
+      },
+      "msvs_settings": {
+        "VCCLCompilerTool": { "ExceptionHandling": 1 }
+      },
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').gyp\")"
+      ],
+      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ]
+    }
+  ]
+}
+

data/bindings/nodejs/fastqr_node.cpp

@@ -0,0 +1,125 @@
+/*
+ * FastQR Node.js Binding
+ * Copyright (C) 2025 FastQR Project
+ */
+
+#include "fastqr.h"
+#include <napi.h>
+
+// Convert JS object to QROptions
+fastqr::QROptions js_to_options(const Napi::Object& obj) {
+    fastqr::QROptions options;
+
+    // Size (preferred) or width/height (backward compatibility)
+    if (obj.Has("size")) {
+        options.size = obj.Get("size").As<Napi::Number>().Int32Value();
+    } else {
+        if (obj.Has("width")) {
+            options.size = obj.Get("width").As<Napi::Number>().Int32Value();
+        }
+        if (obj.Has("height")) {
+            options.size = obj.Get("height").As<Napi::Number>().Int32Value();
+        }
+    }
+
+    // Optimize size
+    if (obj.Has("optimizeSize")) {
+        options.optimize_size = obj.Get("optimizeSize").As<Napi::Boolean>().Value();
+    }
+
+    // Foreground color
+    if (obj.Has("foreground")) {
+        auto fg = obj.Get("foreground").As<Napi::Array>();
+        options.foreground.r = fg.Get(uint32_t(0)).As<Napi::Number>().Uint32Value();
+        options.foreground.g = fg.Get(uint32_t(1)).As<Napi::Number>().Uint32Value();
+        options.foreground.b = fg.Get(uint32_t(2)).As<Napi::Number>().Uint32Value();
+    }
+
+    // Background color
+    if (obj.Has("background")) {
+        auto bg = obj.Get("background").As<Napi::Array>();
+        options.background.r = bg.Get(uint32_t(0)).As<Napi::Number>().Uint32Value();
+        options.background.g = bg.Get(uint32_t(1)).As<Napi::Number>().Uint32Value();
+        options.background.b = bg.Get(uint32_t(2)).As<Napi::Number>().Uint32Value();
+    }
+
+    // Error correction level
+    if (obj.Has("errorLevel")) {
+        std::string level = obj.Get("errorLevel").As<Napi::String>().Utf8Value();
+        if (level == "L") options.ec_level = fastqr::ErrorCorrectionLevel::LOW;
+        else if (level == "M") options.ec_level = fastqr::ErrorCorrectionLevel::MEDIUM;
+        else if (level == "Q") options.ec_level = fastqr::ErrorCorrectionLevel::QUARTILE;
+        else if (level == "H") options.ec_level = fastqr::ErrorCorrectionLevel::HIGH;
+    }
+
+    // Logo
+    if (obj.Has("logo")) {
+        options.logo_path = obj.Get("logo").As<Napi::String>().Utf8Value();
+    }
+    if (obj.Has("logoSize")) {
+        options.logo_size_percent = obj.Get("logoSize").As<Napi::Number>().Int32Value();
+    }
+
+    // Quality and format
+    if (obj.Has("quality")) {
+        options.quality = obj.Get("quality").As<Napi::Number>().Int32Value();
+    }
+    if (obj.Has("format")) {
+        options.format = obj.Get("format").As<Napi::String>().Utf8Value();
+    }
+
+    return options;
+}
+
+// generate(data, outputPath, options)
+Napi::Value Generate(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected at least 2 arguments")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (!info[0].IsString()) {
+        Napi::TypeError::New(env, "First argument must be a string")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (!info[1].IsString()) {
+        Napi::TypeError::New(env, "Second argument must be a string")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    std::string data = info[0].As<Napi::String>().Utf8Value();
+    std::string output_path = info[1].As<Napi::String>().Utf8Value();
+
+    fastqr::QROptions options;
+    if (info.Length() >= 3 && info[2].IsObject()) {
+        options = js_to_options(info[2].As<Napi::Object>());
+    }
+
+    bool result = fastqr::generate(data, output_path, options);
+
+    return Napi::Boolean::New(env, result);
+}
+
+// version()
+Napi::Value Version(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::String::New(env, fastqr::version());
+}
+
+// Initialize module
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports.Set("generate", Napi::Function::New(env, Generate));
+    exports.Set("version", Napi::Function::New(env, Version));
+    exports.Set("VERSION", Napi::String::New(env, fastqr::version()));
+
+    return exports;
+}
+
+NODE_API_MODULE(fastqr, Init)
+

data/bindings/nodejs/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * FastQR TypeScript definitions
+ */
+
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+}
+
+export interface QROptions {
+    /** Output size in pixels (default: 300, QR codes are square) */
+    size?: number;
+
+    /** Auto round-up to nearest integer multiple for best performance (default: false) */
+    optimizeSize?: boolean;
+
+    /** @deprecated Use size instead */
+    width?: number;
+
+    /** @deprecated Use size instead */
+    height?: number;
+
+    /** QR code color as [R, G, B] (default: [0, 0, 0]) */
+    foreground?: [number, number, number];
+
+    /** Background color as [R, G, B] (default: [255, 255, 255]) */
+    background?: [number, number, number];
+
+    /** Error correction level: 'L', 'M', 'Q', 'H' (default: 'M') */
+    errorLevel?: 'L' | 'M' | 'Q' | 'H';
+
+    /** Path to logo image */
+    logo?: string;
+
+    /** Logo size as percentage (default: 20) */
+    logoSize?: number;
+
+    /** Image quality 1-100 (default: 95) */
+    quality?: number;
+
+    /** Output format: 'png', 'jpg', 'webp' (default: 'png') */
+    format?: 'png' | 'jpg' | 'jpeg' | 'webp';
+}
+
+/**
+ * Generate QR code
+ * @param data - Data to encode (UTF-8 supported)
+ * @param outputPath - Path to save the QR code image
+ * @param options - Generation options
+ * @returns true if successful
+ *
+ * @example
+ * ```typescript
+ * import * as fastqr from 'fastqr';
+ *
+ * // Basic usage
+ * fastqr.generate('Hello World', 'qr.png');
+ *
+ * // With options
+ * fastqr.generate('Hello', 'qr.png', {
+ *   size: 500,
+ *   optimizeSize: true,
+ *   foreground: [255, 0, 0],
+ *   background: [255, 255, 200],
+ *   errorLevel: 'H'
+ * });
+ * ```
+ */
+export function generate(data: string, outputPath: string, options?: QROptions): boolean;
+
+/**
+ * Get library version
+ * @returns Version string
+ */
+export function version(): string;
+
+/** Library version constant */
+export const VERSION: string;
+

data/bindings/nodejs/index.js

@@ -0,0 +1,187 @@
+/**
+ * FastQR - Fast QR Code Generator
+ * Node.js Binding
+ */
+
+const platform = require('./lib/platform');
+const ffi = require('ffi-napi');
+const ref = require('ref-napi');
+const path = require('path');
+
+let fastqr;
+
+// Try to load pre-built binary first, fall back to compiled addon
+if (platform.isPrebuiltAvailable()) {
+  // Load via FFI
+  const libPath = platform.getPrebuiltPath();
+
+  const lib = ffi.Library(libPath, {
+    'fastqr_generate': ['bool', ['string', 'string', 'pointer']],
+    'fastqr_version': ['string', []]
+  });
+
+  // Wrap FFI functions to match Node addon interface
+  fastqr = {
+    generate: function(data, outputPath, options = {}) {
+      // TODO: Convert options to C struct
+      // For now, use default options (NULL pointer)
+      return lib.fastqr_generate(data, outputPath, ref.NULL);
+    },
+    version: function() {
+      return lib.fastqr_version();
+    },
+    VERSION: lib.fastqr_version()
+  };
+} else if (platform.isAddonAvailable()) {
+  // Load compiled addon
+  fastqr = require(platform.getAddonPath());
+} else {
+  throw new Error(
+    'FastQR native binding not found. ' +
+    'Please run: npm install --build-from-source'
+  );
+}
+
+/**
+ * QR code generation options
+ * @typedef {Object} QROptions
+ * @property {number} [width=300] - Output width in pixels
+ * @property {number} [height=300] - Output height in pixels
+ * @property {number[]} [foreground=[0,0,0]] - QR code color as [R, G, B]
+ * @property {number[]} [background=[255,255,255]] - Background color as [R, G, B]
+ * @property {string} [errorLevel='M'] - Error correction level: 'L', 'M', 'Q', 'H'
+ * @property {string} [logo] - Path to logo image
+ * @property {number} [logoSize=20] - Logo size as percentage
+ * @property {number} [quality=95] - Image quality (1-100)
+ * @property {string} [format='png'] - Output format: 'png', 'jpg', 'webp'
+ */
+
+/**
+ * Generate QR code
+ * @param {string} data - Data to encode (UTF-8 supported)
+ * @param {string} outputPath - Path to save the QR code image
+ * @param {QROptions} [options={}] - Generation options
+ * @returns {boolean} true if successful
+ *
+ * @example
+ * const fastqr = require('fastqr');
+ *
+ * // Basic usage
+ * fastqr.generate('Hello World', 'qr.png');
+ *
+ * // With options
+ * fastqr.generate('Hello', 'qr.png', {
+ *   width: 500,
+ *   height: 500,
+ *   foreground: [255, 0, 0],
+ *   background: [255, 255, 200],
+ *   errorLevel: 'H'
+ * });
+ *
+ * // With logo
+ * fastqr.generate('Company', 'qr.png', {
+ *   width: 600,
+ *   height: 600,
+ *   logo: 'logo.png',
+ *   logoSize: 25
+ * });
+ *
+ * // UTF-8 support
+ * fastqr.generate('Xin chào Việt Nam! 🇻🇳', 'vietnamese.png');
+ * fastqr.generate('こんにちは日本', 'japanese.png');
+ */
+function generate(data, outputPath, options = {}) {
+    if (!data || typeof data !== 'string') {
+        throw new TypeError('Data must be a non-empty string');
+    }
+    if (!outputPath || typeof outputPath !== 'string') {
+        throw new TypeError('Output path must be a non-empty string');
+    }
+
+    const result = fastqr.generate(data, outputPath, options);
+    if (!result) {
+        throw new Error('Failed to generate QR code');
+    }
+    return result;
+}
+
+/**
+ * Get library version
+ * @returns {string} Version string
+ */
+function version() {
+    return fastqr.version();
+}
+
+/**
+ * Generate multiple QR codes in batch mode (7x faster!)
+ * @param {string[]} dataArray - Array of strings to encode
+ * @param {string} outputDir - Directory to save QR codes (will be created if it doesn't exist)
+ * @param {QROptions} [options={}] - Generation options (same as generate)
+ * @returns {Object} Result with success and failed counts
+ *
+ * @example
+ * const fastqr = require('fastqr');
+ *
+ * // Batch generation
+ * const data = ['QR 1', 'QR 2', 'QR 3'];
+ * fastqr.generateBatch(data, 'output_dir/', { size: 500 });
+ * // Creates: output_dir/1.png, output_dir/2.png, output_dir/3.png
+ */
+function generateBatch(dataArray, outputDir, options = {}) {
+    if (!Array.isArray(dataArray) || dataArray.length === 0) {
+        throw new TypeError('Data array must be a non-empty array');
+    }
+    if (!outputDir || typeof outputDir !== 'string') {
+        throw new TypeError('Output directory must be a non-empty string');
+    }
+
+    const fs = require('fs');
+    const { execFileSync } = require('child_process');
+    const os = require('os');
+    const path = require('path');
+
+    // Create output directory
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Create temporary batch file
+    const tempFile = path.join(os.tmpdir(), `fastqr_batch_${Date.now()}.txt`);
+    try {
+        fs.writeFileSync(tempFile, dataArray.join('\n'), 'utf8');
+
+        // Get CLI path
+        const cliPath = platform.getPrebuiltPath().replace('.dylib', '').replace('.so', '');
+        const actualCliPath = cliPath.endsWith('fastqr') ? cliPath : path.join(path.dirname(cliPath), 'fastqr');
+
+        // Build command arguments
+        const args = ['-F', tempFile, outputDir];
+        if (options.size) args.push('-s', options.size.toString());
+        if (options.optimizeSize) args.push('-o');
+        if (options.foreground) args.push('-f', options.foreground.join(','));
+        if (options.background) args.push('-b', options.background.join(','));
+        if (options.errorLevel) args.push('-e', options.errorLevel);
+        if (options.logo) args.push('-l', options.logo);
+        if (options.logoSize) args.push('-p', options.logoSize.toString());
+        if (options.quality) args.push('-q', options.quality.toString());
+
+        execFileSync(actualCliPath, args, { stdio: 'pipe' });
+
+        return { success: dataArray.length, failed: 0 };
+    } catch (error) {
+        throw new Error(`Batch generation failed: ${error.message}`);
+    } finally {
+        if (fs.existsSync(tempFile)) {
+            fs.unlinkSync(tempFile);
+        }
+    }
+}
+
+module.exports = {
+    generate,
+    generateBatch,
+    version,
+    VERSION: fastqr.VERSION
+};
+

data/bindings/nodejs/lib/platform.js

@@ -0,0 +1,72 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+/**
+ * Detects the current platform and architecture
+ * @returns {string} Platform identifier (e.g., 'macos-arm64', 'linux-x86_64')
+ */
+function detectPlatform() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  if (platform === 'darwin') {
+    if (arch === 'arm64') return 'macos-arm64';
+    if (arch === 'x64') return 'macos-x86_64';
+  } else if (platform === 'linux') {
+    if (arch === 'x64') return 'linux-x86_64';
+    if (arch === 'arm64') return 'linux-arm64';
+  }
+
+  throw new Error(`Unsupported platform: ${platform}-${arch}`);
+}
+
+/**
+ * Extracts pre-built binary from tarball
+ * @param {string} tarballPath - Path to the tarball
+ * @param {string} destDir - Destination directory
+ */
+function extractBinary(tarballPath, destDir) {
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  execSync(`tar -xzf "${tarballPath}" -C "${destDir}"`, { stdio: 'inherit' });
+}
+
+/**
+ * Finds the fastqr binary in prebuilt directory
+ * @returns {string} Path to fastqr binary
+ */
+function findFastQRBinary() {
+  const platform = detectPlatform();
+  const prebuiltDir = path.join(__dirname, '..', 'prebuilt', platform);
+  const binaryPath = path.join(prebuiltDir, 'fastqr');
+
+  if (fs.existsSync(binaryPath)) {
+    // Make sure it's executable
+    fs.chmodSync(binaryPath, 0o755);
+    return binaryPath;
+  }
+
+  // Try to extract from tarball
+  const tarballPath = path.join(__dirname, '..', 'prebuilt', `${platform}.tar.gz`);
+  if (fs.existsSync(tarballPath)) {
+    console.log(`Extracting pre-built binary from ${tarballPath}...`);
+    extractBinary(tarballPath, prebuiltDir);
+
+    if (fs.existsSync(binaryPath)) {
+      fs.chmodSync(binaryPath, 0o755);
+      return binaryPath;
+    }
+  }
+
+  throw new Error(`Pre-built binary not found for ${platform}`);
+}
+
+module.exports = {
+  detectPlatform,
+  extractBinary,
+  findFastQRBinary
+};

data/bindings/nodejs/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "fastqr",
+  "version": "1.0.1",
+  "description": "Fast QR code generator with UTF-8 support, custom colors, logo embedding, and precise size control",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "install": "node-gyp rebuild",
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "qr",
+    "qrcode",
+    "qr-code",
+    "generator",
+    "utf8",
+    "unicode",
+    "vietnamese",
+    "japanese",
+    "fast",
+    "vips",
+    "image"
+  ],
+  "author": "FastQR Project",
+  "license": "LGPL-2.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tranhuucanh/fastqr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tranhuucanh/fastqr/issues"
+  },
+  "homepage": "https://github.com/tranhuucanh/fastqr#readme",
+  "dependencies": {
+    "node-gyp": "^9.0.0",
+    "ffi-napi": "^4.0.3",
+    "ref-napi": "^3.0.3"
+  },
+  "devDependencies": {},
+  "gypfile": true,
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}
+

data/bindings/nodejs/test/test.js

@@ -0,0 +1,45 @@
+const fastqr = require('./index');
+
+console.log('FastQR Node.js Test');
+console.log('Version:', fastqr.version());
+console.log('');
+
+try {
+    // Basic test
+    console.log('Test 1: Basic QR code...');
+    fastqr.generate('Hello, FastQR from Node.js!', 'test_basic.png');
+    console.log('✓ Generated test_basic.png');
+
+    // Colored QR
+    console.log('\nTest 2: Colored QR code...');
+    fastqr.generate('Colored QR', 'test_colored.png', {
+        width: 500,
+        height: 500,
+        foreground: [255, 0, 0],
+        background: [255, 255, 200]
+    });
+    console.log('✓ Generated test_colored.png');
+
+    // UTF-8 Vietnamese
+    console.log('\nTest 3: Vietnamese text...');
+    fastqr.generate('Xin chào Việt Nam! 🇻🇳', 'test_vietnamese.png', {
+        width: 400,
+        height: 400
+    });
+    console.log('✓ Generated test_vietnamese.png');
+
+    // UTF-8 Japanese
+    console.log('\nTest 4: Japanese text...');
+    fastqr.generate('こんにちは日本', 'test_japanese.png', {
+        width: 400,
+        height: 400,
+        foreground: [0, 0, 255]
+    });
+    console.log('✓ Generated test_japanese.png');
+
+    console.log('\n✓ All tests passed!');
+} catch (error) {
+    console.error('✗ Test failed:', error.message);
+    process.exit(1);
+}
+

data/bindings/php/fastqr_php.cpp

@@ -0,0 +1,85 @@
+/*
+ * FastQR PHP C Wrapper
+ * Copyright (C) 2025 FastQR Project
+ */
+
+#include "fastqr.h"
+#include <cstring>
+
+extern "C" {
+
+// C-compatible options structure
+struct QROptions_C {
+    int size;
+    int optimize_size;
+    unsigned char foreground_r;
+    unsigned char foreground_g;
+    unsigned char foreground_b;
+    unsigned char background_r;
+    unsigned char background_g;
+    unsigned char background_b;
+    int ec_level;  // 0=L, 1=M, 2=Q, 3=H
+    const char* logo_path;
+    int logo_size_percent;
+    const char* format;
+    int quality;
+};
+
+// Convert C struct to C++ options
+fastqr::QROptions c_to_cpp_options(const QROptions_C* c_opts) {
+    fastqr::QROptions opts;
+
+    if (c_opts) {
+        opts.size = c_opts->size;
+        opts.optimize_size = c_opts->optimize_size != 0;
+
+        opts.foreground.r = c_opts->foreground_r;
+        opts.foreground.g = c_opts->foreground_g;
+        opts.foreground.b = c_opts->foreground_b;
+
+        opts.background.r = c_opts->background_r;
+        opts.background.g = c_opts->background_g;
+        opts.background.b = c_opts->background_b;
+
+        switch (c_opts->ec_level) {
+            case 0: opts.ec_level = fastqr::ErrorCorrectionLevel::LOW; break;
+            case 1: opts.ec_level = fastqr::ErrorCorrectionLevel::MEDIUM; break;
+            case 2: opts.ec_level = fastqr::ErrorCorrectionLevel::QUARTILE; break;
+            case 3: opts.ec_level = fastqr::ErrorCorrectionLevel::HIGH; break;
+            default: opts.ec_level = fastqr::ErrorCorrectionLevel::MEDIUM; break;
+        }
+
+        if (c_opts->logo_path) {
+            opts.logo_path = c_opts->logo_path;
+        }
+        opts.logo_size_percent = c_opts->logo_size_percent;
+
+        if (c_opts->format) {
+            opts.format = c_opts->format;
+        }
+        opts.quality = c_opts->quality;
+    }
+
+    return opts;
+}
+
+// C-compatible generate function
+bool fastqr_generate(const char* data, const char* output_path, QROptions_C* options) {
+    if (!data || !output_path) {
+        return false;
+    }
+
+    std::string data_str(data);
+    std::string output_str(output_path);
+    fastqr::QROptions opts = c_to_cpp_options(options);
+
+    return fastqr::generate(data_str, output_str, opts);
+}
+
+// C-compatible version function
+const char* fastqr_version(void) {
+    return fastqr::version();
+}
+
+} // extern "C"
+