@luckykiet/node-printer 1.0.0

package/lib/printer.js

@@ -0,0 +1,330 @@
+var printer_helper = {},
+    fs = require("fs"),
+    child_process = require("child_process"),
+    os = require("os"),
+    path = require("path"),
+    binding_path = path.resolve(__dirname, './node_printer.node'),
+    printer_helper;
+
+if(fs.existsSync(binding_path)) {
+    printer_helper = require(binding_path);
+} else {
+    printer_helper = require('./node_printer_'+process.platform+'_'+process.arch+'.node');
+}
+
+/** Return all installed printers including active jobs
+ */
+module.exports.getPrinters = getPrinters;
+
+/** send data to printer
+ */
+module.exports.printDirect = printDirect;
+
+/// send file to printer
+module.exports.printFile = printFile;
+
+/** Get supported print format for printDirect
+ */
+module.exports.getSupportedPrintFormats = printer_helper.getSupportedPrintFormats;
+
+/**
+ * Get possible job command for setJob. It depends on os.
+ * @return Array of string. e.g.: DELETE, PAUSE, RESUME
+ */
+module.exports.getSupportedJobCommands = printer_helper.getSupportedJobCommands;
+
+/** get printer info object. It includes all active jobs
+ */
+module.exports.getPrinter = getPrinter;
+module.exports.getSelectedPaperSize = getSelectedPaperSize;
+module.exports.getPrinterDriverOptions = getPrinterDriverOptions;
+
+/// Return default printer name
+module.exports.getDefaultPrinterName = getDefaultPrinterName;
+
+/** get printer job info object
+ */
+module.exports.getJob = getJob;
+module.exports.setJob = setJob;
+
+/**
+ * return user defined printer, according to https://www.cups.org/documentation.php/doc-2.0/api-cups.html#cupsGetDefault2 :
+ * "Applications should use the cupsGetDests and cupsGetDest functions to get the user-defined default printer,
+ * as this function does not support the lpoptions-defined default printer"
+ */
+function getDefaultPrinterName() {
+  var printerName = printer_helper.getDefaultPrinterName();
+  if(printerName) {
+    return printerName;
+  }
+
+  // seems correct posix behaviour
+  var printers= getPrinters();
+  if(printers && printers.length){
+    var i = printers.length;
+    for(i in printers) {
+        var printer = printers[i];
+        if(printer.isDefault === true) {
+            return printer.name;
+        }
+    }
+  }
+
+  // printer not found, return nothing(undefined)
+}
+
+/** Get printer info with jobs
+ * @param printerName printer name to extract the info
+ * @return printer object info:
+ *		TODO: to enum all possible attributes
+ */
+function getPrinter(printerName)
+{
+    if(!printerName) {
+        printerName = getDefaultPrinterName();
+    }
+    var printer = printer_helper.getPrinter(printerName);
+    correctPrinterinfo(printer);
+    return printer;
+}
+
+/** Get printer driver options includes advanced options like supported paper size
+ * @param printerName printer name to extract the info (default printer used if printer is not provided)
+ * @return printer driver info:
+ */
+function getPrinterDriverOptions(printerName)
+{
+    if(!printerName) {
+        printerName = getDefaultPrinterName();
+    }
+
+    return printer_helper.getPrinterDriverOptions(printerName);
+}
+
+/** Finds selected paper size pertaining to the specific printer out of all supported ones in driver_options
+ * @param printerName printer name to extract the info (default printer used if printer is not provided)
+ * @return selected paper size
+ */
+function getSelectedPaperSize(printerName){
+    var driver_options = getPrinterDriverOptions(printerName);
+    var selectedSize = "";
+    if (driver_options && driver_options.PageSize) {
+        Object.keys(driver_options.PageSize).forEach(function(key){
+            if (driver_options.PageSize[key])
+                selectedSize = key;
+        });
+    }
+    return selectedSize;
+}
+
+function getJob(printerName, jobId)
+{
+    return printer_helper.getJob(printerName, jobId);
+}
+
+function setJob(printerName, jobId, command)
+{
+    return printer_helper.setJob(printerName, jobId, command);
+}
+
+function getPrinters(){
+    var printers = printer_helper.getPrinters();
+    if(printers && printers.length){
+        var i = printers.length;
+        for(i in printers){
+            correctPrinterinfo(printers[i]);
+        }
+    }
+    return printers;
+}
+
+function correctPrinterinfo(printer) {
+    if(printer.status || !printer.options || !printer.options['printer-state']){
+        return;
+    }
+
+    var status = printer.options['printer-state'];
+    // Add posix status
+    if(status == '3'){
+        status = 'IDLE'
+    }
+    else if(status == '4'){
+        status = 'PRINTING'
+    }
+    else if(status == '5'){
+        status = 'STOPPED'
+    }
+
+    // correct date type
+    var k;
+    for(k in printer.options) {
+        if(/time$/.test(k) && printer.options[k] && !(printer.options[k] instanceof Date)) {
+            printer.options[k] = new Date(printer.options[k] * 1000);
+        }
+    }
+
+    printer.status = status;
+}
+
+/*
+ print raw data. This function is intend to be asynchronous
+
+ parameters:
+ parameters - Object, parameters objects with the following structure:
+ data - String, mandatory, data to printer
+ printer - String, optional, name of the printer, if missing, will try to print to default printer
+ docname - String, optional, name of document showed in printer status
+ type - String, optional, only for wind32, data type, one of the RAW, TEXT
+ options - JS object with CUPS options, optional
+ success - Function, optional, callback function
+ error - Function, optional, callback function if exists any error
+
+ or
+
+ data - String, mandatory, data to printer
+ printer - String, optional, name of the printer, if missing, will try to print to default printer
+ docname - String, optional, name of document showed in printer status
+ type - String, optional, data type, one of the RAW, TEXT
+ options - JS object with CUPS options, optional
+ success - Function, optional, callback function with first argument job_id
+ error - Function, optional, callback function if exists any error
+ */
+function printDirect(parameters){
+    var data = parameters
+        , printer
+        , docname
+        , type
+        , options
+        , success
+        , error;
+
+    if(arguments.length==1){
+        //TODO: check parameters type
+        //if (typeof parameters )
+        data = parameters.data;
+        printer = parameters.printer;
+        docname = parameters.docname;
+        type = parameters.type;
+        options = parameters.options||{};
+        success = parameters.success;
+        error = parameters.error;
+    }else{
+        printer = arguments[1];
+        type = arguments[2];
+        docname = arguments[3];
+        options = arguments[4];
+        success = arguments[5];
+        error = arguments[6];
+    }
+
+    if(!type){
+        type = "RAW";
+    }
+
+    // Set default printer name
+    if(!printer) {
+        printer = getDefaultPrinterName();
+    }
+
+    type = type.toUpperCase();
+
+    if(!docname){
+        docname = "node print job";
+    }
+
+    if (!options){
+        options = {};
+    }
+
+    //TODO: check parameters type
+    if(printer_helper.printDirect){// call C++ binding
+        try{
+            var res = printer_helper.printDirect(data, printer, docname, type, options);
+            if(res){
+                success(res);
+            }else{
+                error(Error("Something wrong in printDirect"));
+            }
+        }catch (e){
+            error(e);
+        }
+    }else{
+        error("Not supported");
+    }
+}
+
+/**
+parameters:
+   parameters - Object, parameters objects with the following structure:
+      filename - String, mandatory, data to printer
+      docname - String, optional, name of document showed in printer status
+      printer - String, optional, mane of the printer, if missed, will try to retrieve the default printer name
+      success - Function, optional, callback function
+      error - Function, optional, callback function if exists any error
+*/
+function printFile(parameters){
+    var filename,
+        docname,
+        printer,
+        options,
+        success,
+        error;
+
+    if((arguments.length !== 1) || (typeof(parameters) !== 'object')){
+        throw new Error('must provide arguments object');
+    }
+
+    filename = parameters.filename;
+    docname = parameters.docname;
+    printer = parameters.printer;
+    options = parameters.options || {};
+    success = parameters.success;
+    error = parameters.error;
+
+    if(!success){
+        success = function(){};
+    }
+
+    if(!error){
+        error = function(err){
+            throw err;
+        };
+    }
+
+    if(!filename){
+        var err = new Error('must provide at least a filename');
+        return error(err);
+    }
+
+    // try to define default printer name
+    if(!printer) {
+        printer = getDefaultPrinterName();
+    }
+
+    if(!printer) {
+        return error(new Error('Printer parameter of default printer is not defined'));
+    }
+
+    // set filename if docname is missing
+    if(!docname){
+        docname = filename;
+    }
+
+    //TODO: check parameters type
+    if(printer_helper.printFile){// call C++ binding
+        try{
+            // TODO: proper success/error callbacks from the extension
+            var res = printer_helper.printFile(filename, docname, printer, options);
+
+            if(!isNaN(parseInt(res))) {
+                success(res);
+            } else {
+                error(Error(res));
+            }
+        } catch (e) {
+            error(e);
+        }
+    } else {
+        error("Not supported");
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@luckykiet/node-printer",
+  "description": "Node.js native printer bindings. Fork of @thiagoelg/node-printer with Node 24+ support.",
+  "version": "1.0.0",
+  "homepage": "https://github.com/luckykiet/node-printer",
+  "author": {
+    "name": "Ion Lupascu",
+    "url": "http://program-support.co.uk/",
+    "email": "ionlupascu@gmail.com"
+  },
+  "contributors": [
+    "Thiago Lugli <thiagoelg@gmail.com>",
+    "Eko Eryanto <ekoeryanto@gmail.com>",
+    "luckykiet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/luckykiet/node-printer.git"
+  },
+  "devDependencies": {
+    "nodeunit": "*",
+    "prebuild": "^13.0.1",
+    "node-abi": "^4.26.0"
+  },
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "scripts": {
+    "install": "prebuild-install || node-gyp rebuild",
+    "prebuild-all": "prebuild --all --force --strip --verbose",
+    "prebuild": "prebuild",
+    "rebuild": "node-gyp rebuild",
+    "test": "nodeunit test"
+  },
+  "binary": {
+    "module_name": "node_printer",
+    "module_path": "./lib/",
+    "host": "https://github.com/luckykiet/node-printer/releases/download/",
+    "remote_path": "v{version}"
+  },
+  "license": "MIT",
+  "main": "./lib/printer",
+  "dependencies": {
+    "nan": "^2.25.0",
+    "prebuild-install": "^7.1.3"
+  },
+  "types": "types/index.d.ts"
+}

package/printer.js

@@ -0,0 +1 @@
+module.exports = require('./lib/printer');

package/src/macros.hh

@@ -0,0 +1,159 @@
+#ifndef NODE_PRINTER_SRC_MACROS_H
+#define NODE_PRINTER_SRC_MACROS_H
+
+#include <nan.h>
+#include <node_version.h>
+
+// NODE_MODULE_VERSION was incremented for v0.11
+
+#if NODE_VERSION_AT_LEAST(0, 11, 10)
+#  define MY_NODE_MODULE_ISOLATE_DECL v8::Isolate* isolate = v8::Isolate::GetCurrent();
+#  define MY_NODE_MODULE_ISOLATE      isolate
+#  define MY_NODE_MODULE_HANDLESCOPE MY_NODE_MODULE_ISOLATE_DECL Nan::HandleScope scope
+#  define V8_VALUE_NEW(type, value)   v8::type::New(MY_NODE_MODULE_ISOLATE, value)
+#  define V8_VALUE_NEW_DEFAULT(type)   v8::type::New(MY_NODE_MODULE_ISOLATE)
+#  if NODE_MODULE_VERSION > 73
+#   define V8_STRING_NEW_UTF8(value)   v8::String::NewFromUtf8(MY_NODE_MODULE_ISOLATE, value).ToLocalChecked()
+#   define V8_STRING_NEW_2BYTES(value)   v8::String::NewFromTwoByte(MY_NODE_MODULE_ISOLATE, value).ToLocalChecked()
+#  else
+#    define V8_STRING_NEW_UTF8(value)   v8::String::NewFromUtf8(MY_NODE_MODULE_ISOLATE, value)
+#    define V8_STRING_NEW_2BYTES(value)   v8::String::NewFromTwoByte(MY_NODE_MODULE_ISOLATE, value)
+#  endif
+
+#  define RETURN_EXCEPTION(msg)  isolate->ThrowException(Nan::Error(msg));    \
+    return
+
+#  define RETURN_EXCEPTION_STR(msg) RETURN_EXCEPTION(V8_STRING_NEW_UTF8(msg))
+#  define MY_NODE_MODULE_RETURN_VALUE(value)   iArgs.GetReturnValue().Set(value);   \
+    return
+#  define MY_NODE_MODULE_RETURN_UNDEFINED()   return
+#else
+#  define MY_NODE_MODULE_ISOLATE_DECL
+#  define MY_NODE_MODULE_ISOLATE
+#  define MY_NODE_MODULE_HANDLESCOPE Nan::HandleScope scope;
+#  define V8_VALUE_NEW(type, value)   v8::type::New(value)
+#  define V8_VALUE_NEW_DEFAULT(type)   v8::type::New()
+#  define V8_STRING_NEW_UTF8(value)   Nan::Utf8String(value)
+#  define V8_STRING_NEW_2BYTES(value)   v8::String::New(value)
+
+#  define RETURN_EXCEPTION(msg) return v8::ThrowException(Nan::Error(msg)) 
+
+#  define RETURN_EXCEPTION_STR(msg) RETURN_EXCEPTION(V8_STRING_NEW_UTF8(msg))
+#  define MY_NODE_MODULE_RETURN_VALUE(value)   return scope.Close(value)
+#  define MY_NODE_MODULE_RETURN_UNDEFINED()   return scope.Close(v8::Undefined())
+#endif
+
+#if NODE_VERSION_AT_LEAST(4, 0, 0)
+#define V8_LOCAL_STRING_FROM_VALUE(value) value->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>())
+#define REQUIRE_ARGUMENT_INTEGER(args, i, var)                             \
+    int var;                                                                   \
+    if (args[i]->IsInt32()) {                                             \
+        var = args[i]->Int32Value(Nan::GetCurrentContext()).FromJust();                                           \
+    }                                                                          \
+    else {                                                                     \
+        RETURN_EXCEPTION_STR("Argument " #i " must be an integer");                 \
+    }
+#else
+#define V8_LOCAL_STRING_FROM_VALUE(value) value->ToString()
+#define REQUIRE_ARGUMENT_INTEGER(args, i, var)                             \
+    int var;                                                                   \
+    if (args[i]->IsInt32()) {                                             \
+        var = args[i]->Int32Value();                                           \
+    }                                                                          \
+    else {                                                                     \
+        RETURN_EXCEPTION_STR("Argument " #i " must be an integer");                 \
+    }
+#endif
+
+#if NODE_VERSION_AT_LEAST(4, 0, 0)
+#define MY_MODULE_SET_METHOD(exports, name, method) Nan::SetMethod(exports, name, method)
+#define MY_NODE_MODULE_CALLBACK(name) void name(const Nan::FunctionCallbackInfo<v8::Value>& iArgs)
+#else
+#define MY_MODULE_SET_METHOD(exports, name, method) NODE_SET_METHOD(exports, name, method)
+#define MY_NODE_MODULE_CALLBACK(name) void name(const v8::FunctionCallbackInfo<v8::Value>& iArgs)
+#endif
+
+#define V8_STR_CONC(left, right)                              \
+	v8::String::Concat(V8_STRING_NEW_UTF8(left), V8_STRING_NEW_UTF8(right))
+		
+#define REQUIRE_ARGUMENTS(args, n)                                                   \
+    if (args.Length() < (n)) {                                                 \
+        RETURN_EXCEPTION_STR("Expected " #n " arguments");                       \
+    }
+
+
+#define REQUIRE_ARGUMENT_EXTERNAL(i, var)                                      \
+    if (args.Length() <= (i) || !args[i]->IsExternal()) {                      \
+        RETURN_EXCEPTION_STR("Argument " #i " invalid");       \
+    }                                                                          \
+    v8::Local<v8::External> var = v8::Local<v8::External>::Cast(args[i]);
+
+#define REQUIRE_ARGUMENT_OBJECT(args, i, var)                                      \
+    if (args.Length() <= (i) || !args[i]->IsObject()) {                      \
+        RETURN_EXCEPTION_STR("Argument " #i " is not an object");       \
+    }                                                                          \
+    v8::Local<v8::Object> var = v8::Local<v8::Object>::Cast(args[i]);
+
+
+#define REQUIRE_ARGUMENT_FUNCTION(i, var)                                      \
+    if (args.Length() <= (i) || !args[i]->IsFunction()) {                      \
+        RETURN_EXCEPTION_STR("Argument " #i " must be a function");                 \
+    }                                                                          \
+    v8::Local<v8::Function> var = v8::Local<v8::Function>::Cast(args[i]);
+
+
+#define ARG_CHECK_STRING(args, i)                                        \
+    if (args.Length() <= (i) || !args[i]->IsString()) {                        \
+        RETURN_EXCEPTION_STR("Argument " #i " must be a string");                   \
+    }                                                                          \
+
+#define REQUIRE_ARGUMENT_STRING(args, i, var)                                        \
+    ARG_CHECK_STRING(args, i);                                                       \
+    Nan::Utf8String var(V8_LOCAL_STRING_FROM_VALUE(args[i])); \
+
+#if NODE_VERSION_AT_LEAST(12, 0, 0)
+    #define REQUIRE_ARGUMENT_STRINGW(args, i, var)                                        \
+        ARG_CHECK_STRING(args, i);                                                       \
+        v8::String::Value var(MY_NODE_MODULE_ISOLATE, (args[i]));
+#else
+    #define REQUIRE_ARGUMENT_STRINGW(args, i, var)                                        \
+        ARG_CHECK_STRING(args, i);                                                       \
+        v8::String::Value var(V8_LOCAL_STRING_FROM_VALUE(args[i]));
+#endif
+
+#define OPTIONAL_ARGUMENT_FUNCTION(i, var)                                     \
+    v8::Local<v8::Function> var;                                                       \
+    if (args.Length() > i && !args[i]->IsUndefined()) {                        \
+        if (!args[i]->IsFunction()) {                                          \
+            RETURN_EXCEPTION_STR("Argument " #i " must be a function");             \
+        }                                                                      \
+        var = v8::Local<v8::Function>::Cast(args[i]);                                  \
+    }
+
+
+#define OPTIONAL_ARGUMENT_INTEGER(args, i, var, default)                             \
+    int var;                                                                   \
+    if (args.Length() <= (i)) {                                                \
+        var = (default);                                                       \
+    }                                                                          \
+    else if (args[i]->IsInt32()) {                                             \
+        var = args[i]->Int32Value(Nan::GetCurrentContext()).FromJust();                                           \
+    }                                                                          \
+    else {                                                                     \
+        RETURN_EXCEPTION_STR("Argument " #i " must be an integer");                 \
+    }
+#define EMIT_EVENT(obj, argc, argv)                                            \
+    TRY_CATCH_CALL((obj),                                                      \
+        Local<Function>::Cast((obj)->Get(String::NewSymbol("emit"))),          \
+        argc, argv                                                             \
+    );
+
+#define TRY_CATCH_CALL(context, callback, argc, argv)                          \
+{   TryCatch try_catch;                                                        \
+    (callback)->Call((context), (argc), (argv));                               \
+    if (try_catch.HasCaught()) {                                               \
+        FatalException(try_catch);                                             \
+    }                                                                          \
+}
+
+#endif

package/src/node_printer.cc

@@ -0,0 +1,41 @@
+#include "node_printer.hpp"
+
+#include <node_buffer.h>
+
+NAN_MODULE_INIT(Init) {
+// only for node
+    MY_MODULE_SET_METHOD(target, "getPrinters", getPrinters);
+    MY_MODULE_SET_METHOD(target, "getDefaultPrinterName", getDefaultPrinterName);
+    MY_MODULE_SET_METHOD(target, "getPrinter", getPrinter);
+    MY_MODULE_SET_METHOD(target, "getPrinterDriverOptions", getPrinterDriverOptions);
+    MY_MODULE_SET_METHOD(target, "getJob", getJob);
+    MY_MODULE_SET_METHOD(target, "setJob", setJob);
+    MY_MODULE_SET_METHOD(target, "printDirect", PrintDirect);
+    MY_MODULE_SET_METHOD(target, "printFile", PrintFile);
+    MY_MODULE_SET_METHOD(target, "getSupportedPrintFormats", getSupportedPrintFormats);
+    MY_MODULE_SET_METHOD(target, "getSupportedJobCommands", getSupportedJobCommands);
+}
+
+#if NODE_MAJOR_VERSION >= 10
+NAN_MODULE_WORKER_ENABLED(node_printer, Init)
+#else
+NODE_MODULE(node_printer, Init)
+#endif
+
+// Helpers
+
+bool getStringOrBufferFromV8Value(v8::Local<v8::Value> iV8Value, std::string &oData)
+{
+    if(iV8Value->IsString())
+    {
+        Nan::Utf8String data_str_v8(V8_LOCAL_STRING_FROM_VALUE(iV8Value));
+        oData.assign(*data_str_v8, data_str_v8.length());
+        return true;
+    }
+    if(iV8Value->IsObject() && node::Buffer::HasInstance(iV8Value))
+    {
+        oData.assign(node::Buffer::Data(iV8Value), node::Buffer::Length(iV8Value));
+        return true;
+    }
+    return false;
+}