@tbsoft-gmbh/signature-sdk 1.0.0

package/dist/png-decode.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Minimal PNG decoder using only Node.js built-in zlib.
+ * Supports 8-bit RGB, RGBA, Grayscale, and Grayscale+Alpha PNGs.
+ * No external dependencies.
+ */
+interface DecodedPng {
+    width: number;
+    height: number;
+    channels: number;
+    data: Buffer;
+}
+declare function decodePng(buf: Buffer): DecodedPng | null;
+
+export { type DecodedPng, decodePng };

package/dist/png-decode.js

@@ -0,0 +1,141 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/png-decode.ts
+var png_decode_exports = {};
+__export(png_decode_exports, {
+  decodePng: () => decodePng
+});
+module.exports = __toCommonJS(png_decode_exports);
+var import_zlib = __toESM(require("zlib"));
+function decodePng(buf) {
+  if (buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71) {
+    return null;
+  }
+  let offset = 8;
+  let width = 0, height = 0, bitDepth = 0, colorType = 0;
+  const idatChunks = [];
+  while (offset < buf.length) {
+    const chunkLen = buf.readUInt32BE(offset);
+    const chunkType = buf.toString("ascii", offset + 4, offset + 8);
+    if (chunkType === "IHDR") {
+      width = buf.readUInt32BE(offset + 8);
+      height = buf.readUInt32BE(offset + 12);
+      bitDepth = buf[offset + 16];
+      colorType = buf[offset + 17];
+    } else if (chunkType === "IDAT") {
+      idatChunks.push(buf.slice(offset + 8, offset + 8 + chunkLen));
+    } else if (chunkType === "IEND") {
+      break;
+    }
+    offset += 12 + chunkLen;
+  }
+  if (width === 0 || height === 0 || idatChunks.length === 0) return null;
+  let channels;
+  switch (colorType) {
+    case 0:
+      channels = 1;
+      break;
+    // Grayscale
+    case 2:
+      channels = 3;
+      break;
+    // RGB
+    case 4:
+      channels = 2;
+      break;
+    // Grayscale + Alpha
+    case 6:
+      channels = 4;
+      break;
+    // RGBA
+    default:
+      return null;
+  }
+  const compressed = Buffer.concat(idatChunks);
+  let decompressed;
+  try {
+    decompressed = import_zlib.default.inflateSync(compressed);
+  } catch {
+    return null;
+  }
+  const bytesPerPixel = channels * (bitDepth / 8);
+  const stride = width * bytesPerPixel;
+  const pixels = Buffer.alloc(height * stride);
+  let srcOffset = 0;
+  for (let y = 0; y < height; y++) {
+    const filterType = decompressed[srcOffset++];
+    const rowStart = y * stride;
+    const prevRowStart = (y - 1) * stride;
+    for (let x = 0; x < stride; x++) {
+      const raw = decompressed[srcOffset++];
+      let value;
+      switch (filterType) {
+        case 0:
+          value = raw;
+          break;
+        case 1:
+          value = raw + (x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0);
+          break;
+        case 2:
+          value = raw + (y > 0 ? pixels[prevRowStart + x] : 0);
+          break;
+        case 3:
+          const left = x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0;
+          const up = y > 0 ? pixels[prevRowStart + x] : 0;
+          value = raw + Math.floor((left + up) / 2);
+          break;
+        case 4:
+          const a = x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0;
+          const b = y > 0 ? pixels[prevRowStart + x] : 0;
+          const c = x >= bytesPerPixel && y > 0 ? pixels[prevRowStart + x - bytesPerPixel] : 0;
+          value = raw + paethPredictor(a, b, c);
+          break;
+        default:
+          value = raw;
+      }
+      pixels[rowStart + x] = value & 255;
+    }
+  }
+  return { width, height, channels, data: pixels };
+}
+function paethPredictor(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc) return a;
+  if (pb <= pc) return b;
+  return c;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodePng
+});
+//# sourceMappingURL=png-decode.js.map

package/dist/png-decode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/png-decode.ts"],"sourcesContent":["/**\r\n * Minimal PNG decoder using only Node.js built-in zlib.\r\n * Supports 8-bit RGB, RGBA, Grayscale, and Grayscale+Alpha PNGs.\r\n * No external dependencies.\r\n */\r\n\r\nimport zlib from \"zlib\";\r\n\r\nexport interface DecodedPng {\r\n  width: number;\r\n  height: number;\r\n  channels: number; // 1=gray, 2=gray+alpha, 3=RGB, 4=RGBA\r\n  data: Buffer;     // Raw pixel data, row-major, channels interleaved\r\n}\r\n\r\nexport function decodePng(buf: Buffer): DecodedPng | null {\r\n  // Verify PNG signature\r\n  if (buf[0] !== 0x89 || buf[1] !== 0x50 || buf[2] !== 0x4E || buf[3] !== 0x47) {\r\n    return null;\r\n  }\r\n\r\n  let offset = 8; // Skip signature\r\n  let width = 0, height = 0, bitDepth = 0, colorType = 0;\r\n  const idatChunks: Buffer[] = [];\r\n\r\n  // Parse chunks\r\n  while (offset < buf.length) {\r\n    const chunkLen = buf.readUInt32BE(offset);\r\n    const chunkType = buf.toString(\"ascii\", offset + 4, offset + 8);\r\n\r\n    if (chunkType === \"IHDR\") {\r\n      width = buf.readUInt32BE(offset + 8);\r\n      height = buf.readUInt32BE(offset + 12);\r\n      bitDepth = buf[offset + 16];\r\n      colorType = buf[offset + 17];\r\n    } else if (chunkType === \"IDAT\") {\r\n      idatChunks.push(buf.slice(offset + 8, offset + 8 + chunkLen));\r\n    } else if (chunkType === \"IEND\") {\r\n      break;\r\n    }\r\n\r\n    offset += 12 + chunkLen; // 4 len + 4 type + data + 4 crc\r\n  }\r\n\r\n  if (width === 0 || height === 0 || idatChunks.length === 0) return null;\r\n\r\n  // Determine channels from color type\r\n  let channels: number;\r\n  switch (colorType) {\r\n    case 0: channels = 1; break; // Grayscale\r\n    case 2: channels = 3; break; // RGB\r\n    case 4: channels = 2; break; // Grayscale + Alpha\r\n    case 6: channels = 4; break; // RGBA\r\n    default: return null;         // Indexed/other not supported\r\n  }\r\n\r\n  // Decompress IDAT data\r\n  const compressed = Buffer.concat(idatChunks);\r\n  let decompressed: Buffer;\r\n  try {\r\n    decompressed = zlib.inflateSync(compressed);\r\n  } catch {\r\n    return null;\r\n  }\r\n\r\n  // Apply PNG filtering (each row has a filter byte prefix)\r\n  const bytesPerPixel = channels * (bitDepth / 8);\r\n  const stride = width * bytesPerPixel;\r\n  const pixels = Buffer.alloc(height * stride);\r\n\r\n  let srcOffset = 0;\r\n  for (let y = 0; y < height; y++) {\r\n    const filterType = decompressed[srcOffset++];\r\n    const rowStart = y * stride;\r\n    const prevRowStart = (y - 1) * stride;\r\n\r\n    for (let x = 0; x < stride; x++) {\r\n      const raw = decompressed[srcOffset++];\r\n      let value: number;\r\n\r\n      switch (filterType) {\r\n        case 0: // None\r\n          value = raw;\r\n          break;\r\n        case 1: // Sub\r\n          value = raw + (x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0);\r\n          break;\r\n        case 2: // Up\r\n          value = raw + (y > 0 ? pixels[prevRowStart + x] : 0);\r\n          break;\r\n        case 3: // Average\r\n          const left = x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0;\r\n          const up = y > 0 ? pixels[prevRowStart + x] : 0;\r\n          value = raw + Math.floor((left + up) / 2);\r\n          break;\r\n        case 4: // Paeth\r\n          const a = x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0;\r\n          const b = y > 0 ? pixels[prevRowStart + x] : 0;\r\n          const c = (x >= bytesPerPixel && y > 0) ? pixels[prevRowStart + x - bytesPerPixel] : 0;\r\n          value = raw + paethPredictor(a, b, c);\r\n          break;\r\n        default:\r\n          value = raw;\r\n      }\r\n\r\n      pixels[rowStart + x] = value & 0xFF;\r\n    }\r\n  }\r\n\r\n  return { width, height, channels, data: pixels };\r\n}\r\n\r\nfunction paethPredictor(a: number, b: number, c: number): number {\r\n  const p = a + b - c;\r\n  const pa = Math.abs(p - a);\r\n  const pb = Math.abs(p - b);\r\n  const pc = Math.abs(p - c);\r\n  if (pa <= pb && pa <= pc) return a;\r\n  if (pb <= pc) return b;\r\n  return c;\r\n}\r\n"],"mappings":"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","names":["zlib"]}

package/dist/signature-renderer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Renders signature strokes into a PNG image buffer.
+ * Pure TypeScript implementation - no canvas or native dependencies.
+ * Uses zlib for PNG compression (built into Node.js).
+ */
+type Point = {
+    x: number;
+    y: number;
+    pressure?: number;
+};
+type Stroke = Point[];
+interface RenderOptions {
+    width: number;
+    height: number;
+    strokeWidth: number;
+    strokeColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    backgroundColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    padding: number;
+    smooth: boolean;
+}
+/**
+ * Render signature strokes to a PNG buffer.
+ */
+declare function renderSignaturePng(strokes: Stroke[], sensorWidth: number, sensorHeight: number, options?: Partial<RenderOptions>): Buffer;
+
+export { type RenderOptions, renderSignaturePng };

package/dist/signature-renderer.js

@@ -0,0 +1,176 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/signature-renderer.ts
+var signature_renderer_exports = {};
+__export(signature_renderer_exports, {
+  renderSignaturePng: () => renderSignaturePng
+});
+module.exports = __toCommonJS(signature_renderer_exports);
+var import_zlib = __toESM(require("zlib"));
+var DEFAULT_OPTIONS = {
+  width: 400,
+  height: 200,
+  strokeWidth: 2,
+  strokeColor: { r: 0, g: 0, b: 0 },
+  backgroundColor: { r: 255, g: 255, b: 255 },
+  padding: 10,
+  smooth: true
+};
+function renderSignaturePng(strokes, sensorWidth, sensorHeight, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const { width, height, strokeWidth, strokeColor, backgroundColor, padding } = opts;
+  const pixels = Buffer.alloc(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    pixels[i * 4] = backgroundColor.r;
+    pixels[i * 4 + 1] = backgroundColor.g;
+    pixels[i * 4 + 2] = backgroundColor.b;
+    pixels[i * 4 + 3] = 255;
+  }
+  if (strokes.length === 0) {
+    return encodePng(pixels, width, height);
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const stroke of strokes) {
+    for (const pt of stroke) {
+      if (pt.x < minX) minX = pt.x;
+      if (pt.y < minY) minY = pt.y;
+      if (pt.x > maxX) maxX = pt.x;
+      if (pt.y > maxY) maxY = pt.y;
+    }
+  }
+  const dataWidth = maxX - minX || 1;
+  const dataHeight = maxY - minY || 1;
+  const scaleX = (width - padding * 2) / dataWidth;
+  const scaleY = (height - padding * 2) / dataHeight;
+  const scale = Math.min(scaleX, scaleY);
+  const offsetX = padding + (width - padding * 2 - dataWidth * scale) / 2;
+  const offsetY = padding + (height - padding * 2 - dataHeight * scale) / 2;
+  for (const stroke of strokes) {
+    if (stroke.length < 2) continue;
+    for (let i = 1; i < stroke.length; i++) {
+      const x0 = offsetX + (stroke[i - 1].x - minX) * scale;
+      const y0 = offsetY + (stroke[i - 1].y - minY) * scale;
+      const x1 = offsetX + (stroke[i].x - minX) * scale;
+      const y1 = offsetY + (stroke[i].y - minY) * scale;
+      drawLine(pixels, width, height, x0, y0, x1, y1, strokeWidth, strokeColor);
+    }
+  }
+  return encodePng(pixels, width, height);
+}
+function drawLine(pixels, imgWidth, imgHeight, x0, y0, x1, y1, thickness, color) {
+  const dx = Math.abs(x1 - x0);
+  const dy = Math.abs(y1 - y0);
+  const sx = x0 < x1 ? 1 : -1;
+  const sy = y0 < y1 ? 1 : -1;
+  let err = dx - dy;
+  const steps = Math.max(Math.ceil(Math.sqrt(dx * dx + dy * dy)), 1);
+  const radius = thickness / 2;
+  for (let step = 0; step <= steps; step++) {
+    const t = steps > 0 ? step / steps : 0;
+    const cx = x0 + (x1 - x0) * t;
+    const cy = y0 + (y1 - y0) * t;
+    const r = Math.ceil(radius);
+    for (let dy2 = -r; dy2 <= r; dy2++) {
+      for (let dx2 = -r; dx2 <= r; dx2++) {
+        if (dx2 * dx2 + dy2 * dy2 <= radius * radius) {
+          const px = Math.round(cx + dx2);
+          const py = Math.round(cy + dy2);
+          if (px >= 0 && px < imgWidth && py >= 0 && py < imgHeight) {
+            const idx = (py * imgWidth + px) * 4;
+            pixels[idx] = color.r;
+            pixels[idx + 1] = color.g;
+            pixels[idx + 2] = color.b;
+            pixels[idx + 3] = 255;
+          }
+        }
+      }
+    }
+  }
+}
+function encodePng(pixels, width, height) {
+  const rawData = Buffer.alloc(height * (1 + width * 4));
+  for (let y = 0; y < height; y++) {
+    rawData[y * (1 + width * 4)] = 0;
+    pixels.copy(
+      rawData,
+      y * (1 + width * 4) + 1,
+      y * width * 4,
+      (y + 1) * width * 4
+    );
+  }
+  const compressed = import_zlib.default.deflateSync(rawData);
+  const chunks = [];
+  chunks.push(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  chunks.push(pngChunk("IHDR", ihdr));
+  chunks.push(pngChunk("IDAT", compressed));
+  chunks.push(pngChunk("IEND", Buffer.alloc(0)));
+  return Buffer.concat(chunks);
+}
+function pngChunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const typeAndData = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = crc32(typeAndData);
+  const crcBuf = Buffer.alloc(4);
+  crcBuf.writeUInt32BE(crc >>> 0, 0);
+  return Buffer.concat([length, typeAndData, crcBuf]);
+}
+var CRC_TABLE = [];
+for (let n = 0; n < 256; n++) {
+  let c = n;
+  for (let k = 0; k < 8; k++) {
+    if (c & 1) {
+      c = 3988292384 ^ c >>> 1;
+    } else {
+      c = c >>> 1;
+    }
+  }
+  CRC_TABLE[n] = c;
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc = CRC_TABLE[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderSignaturePng
+});
+//# sourceMappingURL=signature-renderer.js.map

package/dist/signature-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/signature-renderer.ts"],"sourcesContent":["/**\r\n * Renders signature strokes into a PNG image buffer.\r\n * Pure TypeScript implementation - no canvas or native dependencies.\r\n * Uses zlib for PNG compression (built into Node.js).\r\n */\r\n\r\nimport zlib from \"zlib\";\r\n\r\ntype Point = { x: number; y: number; pressure?: number };\r\ntype Stroke = Point[];\r\n\r\nexport interface RenderOptions {\r\n  width: number;\r\n  height: number;\r\n  strokeWidth: number;\r\n  strokeColor: { r: number; g: number; b: number };\r\n  backgroundColor: { r: number; g: number; b: number };\r\n  padding: number;\r\n  smooth: boolean;\r\n}\r\n\r\nconst DEFAULT_OPTIONS: RenderOptions = {\r\n  width: 400,\r\n  height: 200,\r\n  strokeWidth: 2,\r\n  strokeColor: { r: 0, g: 0, b: 0 },\r\n  backgroundColor: { r: 255, g: 255, b: 255 },\r\n  padding: 10,\r\n  smooth: true,\r\n};\r\n\r\n/**\r\n * Render signature strokes to a PNG buffer.\r\n */\r\nexport function renderSignaturePng(\r\n  strokes: Stroke[],\r\n  sensorWidth: number,\r\n  sensorHeight: number,\r\n  options: Partial<RenderOptions> = {}\r\n): Buffer {\r\n  const opts = { ...DEFAULT_OPTIONS, ...options };\r\n  const { width, height, strokeWidth, strokeColor, backgroundColor, padding } = opts;\r\n\r\n  // Create RGBA pixel buffer\r\n  const pixels = Buffer.alloc(width * height * 4);\r\n\r\n  // Fill background\r\n  for (let i = 0; i < width * height; i++) {\r\n    pixels[i * 4] = backgroundColor.r;\r\n    pixels[i * 4 + 1] = backgroundColor.g;\r\n    pixels[i * 4 + 2] = backgroundColor.b;\r\n    pixels[i * 4 + 3] = 255;\r\n  }\r\n\r\n  if (strokes.length === 0) {\r\n    return encodePng(pixels, width, height);\r\n  }\r\n\r\n  // Calculate bounding box of all strokes\r\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\r\n  for (const stroke of strokes) {\r\n    for (const pt of stroke) {\r\n      if (pt.x < minX) minX = pt.x;\r\n      if (pt.y < minY) minY = pt.y;\r\n      if (pt.x > maxX) maxX = pt.x;\r\n      if (pt.y > maxY) maxY = pt.y;\r\n    }\r\n  }\r\n\r\n  // Scale to fit output dimensions with padding\r\n  const dataWidth = maxX - minX || 1;\r\n  const dataHeight = maxY - minY || 1;\r\n  const scaleX = (width - padding * 2) / dataWidth;\r\n  const scaleY = (height - padding * 2) / dataHeight;\r\n  const scale = Math.min(scaleX, scaleY);\r\n  const offsetX = padding + (width - padding * 2 - dataWidth * scale) / 2;\r\n  const offsetY = padding + (height - padding * 2 - dataHeight * scale) / 2;\r\n\r\n  // Draw strokes\r\n  for (const stroke of strokes) {\r\n    if (stroke.length < 2) continue;\r\n\r\n    for (let i = 1; i < stroke.length; i++) {\r\n      const x0 = offsetX + (stroke[i - 1].x - minX) * scale;\r\n      const y0 = offsetY + (stroke[i - 1].y - minY) * scale;\r\n      const x1 = offsetX + (stroke[i].x - minX) * scale;\r\n      const y1 = offsetY + (stroke[i].y - minY) * scale;\r\n\r\n      drawLine(pixels, width, height, x0, y0, x1, y1, strokeWidth, strokeColor);\r\n    }\r\n  }\r\n\r\n  return encodePng(pixels, width, height);\r\n}\r\n\r\n/**\r\n * Draw an anti-aliased line with thickness using Bresenham + circle brush.\r\n */\r\nfunction drawLine(\r\n  pixels: Buffer,\r\n  imgWidth: number,\r\n  imgHeight: number,\r\n  x0: number, y0: number,\r\n  x1: number, y1: number,\r\n  thickness: number,\r\n  color: { r: number; g: number; b: number }\r\n): void {\r\n  const dx = Math.abs(x1 - x0);\r\n  const dy = Math.abs(y1 - y0);\r\n  const sx = x0 < x1 ? 1 : -1;\r\n  const sy = y0 < y1 ? 1 : -1;\r\n  let err = dx - dy;\r\n\r\n  const steps = Math.max(Math.ceil(Math.sqrt(dx * dx + dy * dy)), 1);\r\n  const radius = thickness / 2;\r\n\r\n  for (let step = 0; step <= steps; step++) {\r\n    const t = steps > 0 ? step / steps : 0;\r\n    const cx = x0 + (x1 - x0) * t;\r\n    const cy = y0 + (y1 - y0) * t;\r\n\r\n    // Draw filled circle at each step\r\n    const r = Math.ceil(radius);\r\n    for (let dy = -r; dy <= r; dy++) {\r\n      for (let dx = -r; dx <= r; dx++) {\r\n        if (dx * dx + dy * dy <= radius * radius) {\r\n          const px = Math.round(cx + dx);\r\n          const py = Math.round(cy + dy);\r\n          if (px >= 0 && px < imgWidth && py >= 0 && py < imgHeight) {\r\n            const idx = (py * imgWidth + px) * 4;\r\n            pixels[idx] = color.r;\r\n            pixels[idx + 1] = color.g;\r\n            pixels[idx + 2] = color.b;\r\n            pixels[idx + 3] = 255;\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Encode RGBA pixel buffer as PNG.\r\n * Minimal PNG encoder - no external dependencies.\r\n */\r\nfunction encodePng(pixels: Buffer, width: number, height: number): Buffer {\r\n  // Build raw image data with filter bytes\r\n  const rawData = Buffer.alloc(height * (1 + width * 4));\r\n  for (let y = 0; y < height; y++) {\r\n    rawData[y * (1 + width * 4)] = 0; // Filter: None\r\n    pixels.copy(\r\n      rawData,\r\n      y * (1 + width * 4) + 1,\r\n      y * width * 4,\r\n      (y + 1) * width * 4\r\n    );\r\n  }\r\n\r\n  // Compress with zlib\r\n  const compressed = zlib.deflateSync(rawData);\r\n\r\n  // Build PNG file\r\n  const chunks: Buffer[] = [];\r\n\r\n  // PNG signature\r\n  chunks.push(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));\r\n\r\n  // IHDR chunk\r\n  const ihdr = Buffer.alloc(13);\r\n  ihdr.writeUInt32BE(width, 0);\r\n  ihdr.writeUInt32BE(height, 4);\r\n  ihdr[8] = 8; // bit depth\r\n  ihdr[9] = 6; // color type: RGBA\r\n  ihdr[10] = 0; // compression\r\n  ihdr[11] = 0; // filter\r\n  ihdr[12] = 0; // interlace\r\n  chunks.push(pngChunk(\"IHDR\", ihdr));\r\n\r\n  // IDAT chunk\r\n  chunks.push(pngChunk(\"IDAT\", compressed));\r\n\r\n  // IEND chunk\r\n  chunks.push(pngChunk(\"IEND\", Buffer.alloc(0)));\r\n\r\n  return Buffer.concat(chunks);\r\n}\r\n\r\nfunction pngChunk(type: string, data: Buffer): Buffer {\r\n  const length = Buffer.alloc(4);\r\n  length.writeUInt32BE(data.length, 0);\r\n\r\n  const typeAndData = Buffer.concat([Buffer.from(type, \"ascii\"), data]);\r\n  const crc = crc32(typeAndData);\r\n  const crcBuf = Buffer.alloc(4);\r\n  crcBuf.writeUInt32BE(crc >>> 0, 0);\r\n\r\n  return Buffer.concat([length, typeAndData, crcBuf]);\r\n}\r\n\r\n// CRC-32 lookup table\r\nconst CRC_TABLE: number[] = [];\r\nfor (let n = 0; n < 256; n++) {\r\n  let c = n;\r\n  for (let k = 0; k < 8; k++) {\r\n    if (c & 1) {\r\n      c = 0xEDB88320 ^ (c >>> 1);\r\n    } else {\r\n      c = c >>> 1;\r\n    }\r\n  }\r\n  CRC_TABLE[n] = c;\r\n}\r\n\r\nfunction crc32(data: Buffer): number {\r\n  let crc = 0xFFFFFFFF;\r\n  for (let i = 0; i < data.length; i++) {\r\n    crc = CRC_TABLE[(crc ^ data[i]) & 0xFF] ^ (crc >>> 8);\r\n  }\r\n  return (crc ^ 0xFFFFFFFF) >>> 0;\r\n}\r\n"],"mappings":"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","names":["dy","dx","zlib"]}

package/dist/types.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Type definitions for the Signotec Pad SDK.
+ * @module types
+ */
+/** Information about a connected Signotec signing pad. */
+type DeviceInfo = {
+    /** Unique identifier (serial number or device path fallback). */
+    serialNo: string;
+    /** Device type code (see DEVICE_TYPE_MAPPINGS). */
+    type: number;
+    /** Human-readable device model name. */
+    name: string;
+    /** Manufacturer name (always "Signotec"). */
+    vendor: string;
+};
+/** Map of device type codes to human-readable model names. */
+declare const DEVICE_TYPE_MAPPINGS: Record<number, string>;
+/**
+ * Handler for user-initiated events (confirm/cancel) from the signing pad.
+ * @param event - "confirm" when signature accepted, "cancel" when cancelled
+ * @param data - Contains serialNo and base64 PNG image (on confirm)
+ */
+type SignatureEventHandler = {
+    (event: "cancel", data: {
+        serialNo: string;
+    }): void;
+    (event: "confirm", data: {
+        serialNo: string;
+        base64Img: string;
+    }): void;
+};
+/**
+ * Handler for real-time signature data streaming.
+ * @param event - "liveData" for each pen point, "clear" when signature cleared (retry)
+ * @param data - Contains point coordinates (x, y) and serialNo
+ */
+type SignatureEventHandlerLive = {
+    (event: "liveData", data: {
+        point: {
+            x: number;
+            y: number;
+            pressure?: number;
+        };
+        serialNo: string;
+    }): void;
+    (event: "clear", data: {
+        serialNo: string;
+    }): void;
+};
+/** Combined callback handlers for a signing session. */
+type SignatureCallbackHandlers = {
+    /** Fires on user actions: confirm (with signature image) or cancel. */
+    onUserEvent: SignatureEventHandler;
+    /** Fires on pen movement (liveData) or signature clear (retry). */
+    onSignatureData: SignatureEventHandlerLive;
+};
+/** A single line of text displayed on the signing pad. */
+type DisplayLine = {
+    /** Label prefix (e.g., "LFS:", "Kunde:"). */
+    label: string;
+    /** Content value displayed after the label. */
+    content: string | number;
+    /** Font scale factor (1 = tiny 5x7, 2 = normal, 3 = large). Default: 2 */
+    fontSize?: number;
+};
+/** Content displayed on the signing pad during a session. */
+type SignatureDisplayData = {
+    /** Main content area (up to 4 lines, displayed below buttons). */
+    body?: {
+        line1?: DisplayLine | null;
+        line2?: DisplayLine | null;
+        line3?: DisplayLine | null;
+        line4?: DisplayLine | null;
+    } | null;
+    /** Footer area (up to 2 lines, displayed at bottom). */
+    footer?: {
+        line1?: DisplayLine | null;
+        line2?: DisplayLine | null;
+    } | null;
+};
+/** Options for the rendered signature image output. */
+type SignatureOutputOptions = {
+    /** Pen stroke width in pixels. Default: 2 */
+    strokeWidth?: number;
+    /** Output image dimensions. Default: 400x200 */
+    imageSize?: {
+        width: number;
+        height: number;
+    };
+    /** DPI resolution for the output image. Default: 300 */
+    resolution?: number;
+};
+/** Options passed to startSigningProcess. */
+type StartSignatureOptions = {
+    /** Text content to display on the pad during signing. */
+    displayData: SignatureDisplayData;
+    /** Configuration for the rendered signature image. */
+    outputOptions?: SignatureOutputOptions;
+};
+/**
+ * Configuration for the HID driver.
+ * Tune timeouts for slow USB-over-IP connections.
+ *
+ * @example
+ * ```typescript
+ * // For USB-over-IP with high latency:
+ * const driver = createHidDriver({
+ *   commandTimeout: 5000,
+ *   chunkDelayMs: 10,
+ *   maxRetries: 3,
+ * });
+ * ```
+ */
+type DriverConfig = {
+    /** Timeout for simple HID commands (ms). Default: 3000 */
+    commandTimeout?: number;
+    /** Timeout for image transfer operations (ms). Default: 15000 */
+    imageTransferTimeout?: number;
+    /** Timeout for flash store operations (ms). Default: 25000 */
+    flashStoreTimeout?: number;
+    /** Delay between data chunks during image transfer (ms). Default: 2.
+     *  Increase for slow USB-over-IP connections. */
+    chunkDelayMs?: number;
+    /** Max retry attempts for failed HID commands. Default: 2 */
+    maxRetries?: number;
+    /** Max reconnection attempts after device disconnect. Default: 10 */
+    reconnectAttempts?: number;
+    /** Delay between reconnection attempts (ms). Default: 2000 */
+    reconnectIntervalMs?: number;
+    /** Logger instance. Defaults to console. Set to null to suppress logs. */
+    logger?: Logger | null;
+    /**
+     * Optional event callback for driver lifecycle events.
+     * Receives structured events for logging to Grafana/Loki/external systems.
+     * Called for: session start/end, errors, warnings, USB diagnostics.
+     *
+     * @example
+     * ```typescript
+     * configure({
+     *   onDriverEvent: (event) => {
+     *     grafanaLogger.log(event.level, event.message, event.data);
+     *   }
+     * });
+     * ```
+     */
+    onDriverEvent?: (event: DriverEvent) => void;
+};
+/** Structured event emitted by the driver for external logging/monitoring. */
+type DriverEvent = {
+    /** Event severity level. */
+    level: "info" | "warn" | "error";
+    /** Human-readable event description. */
+    message: string;
+    /** Event category for filtering. */
+    category: "session" | "device" | "usb" | "display" | "signature" | "flash";
+    /** Optional structured data payload. */
+    data?: Record<string, unknown>;
+    /** ISO timestamp. */
+    timestamp: string;
+};
+/** Minimal logger interface (compatible with console, electron-log, winston, etc.) */
+interface Logger {
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug?(...args: any[]): void;
+}
+/** The public API for the Signotec Pad SDK. */
+interface PadDriver {
+    /**
+     * Get all connected Signotec signing pads.
+     * Returns empty array if no devices found (does NOT throw).
+     */
+    getSignotecPads(): DeviceInfo[];
+    /**
+     * Start a signature capture session on the specified pad.
+     * Draws the signing UI (buttons + text), configures hotspots, starts capture.
+     *
+     * @param serialNo - Serial number of the target pad (from getSignotecPads)
+     * @param handlers - Callback handlers for user events and live signature data
+     * @param options - Display content and output configuration
+     * @throws Error if device cannot be opened or signing session fails to start
+     */
+    startSigningProcess(serialNo: string, handlers: SignatureCallbackHandlers, options: StartSignatureOptions): Promise<void>;
+    /**
+     * Cancel the current signing session.
+     * Fires the 'cancel' user event, restores standby display, closes device.
+     */
+    cancelSignature(): {
+        status: boolean;
+        message: string;
+    };
+    /**
+     * Confirm the current signature.
+     * Renders signature as PNG, fires 'confirm' with base64 image, restores standby.
+     * @throws Error if no active signing session
+     */
+    confirmSignature(): void;
+    /**
+     * Skip signature and continue without one.
+     * Fires 'confirm' with empty base64Img.
+     */
+    continueWithoutSignature(): Promise<{
+        status: boolean;
+        message: string;
+    }>;
+    /**
+     * Store a standby image to the pad's flash memory.
+     * The image persists across power cycles and USB disconnects.
+     * After each signing session, the standby is automatically restored via 0x8A.
+     *
+     * @param imagePath - Path to PNG or BMP image (320x160 for Sigma pads), or null to clear
+     * @returns true if stored successfully
+     */
+    setStandbyImage(imagePath: string | null): Promise<boolean>;
+    /**
+     * Wait for a Signotec pad to be connected.
+     * Polls USB bus until a device appears or timeout expires.
+     *
+     * @param timeoutMs - Maximum wait time in milliseconds. Default: 30000
+     * @returns DeviceInfo of the first device found, or null on timeout
+     */
+    waitForDevice?(timeoutMs?: number): Promise<DeviceInfo | null>;
+}
+
+export { DEVICE_TYPE_MAPPINGS, type DeviceInfo, type DisplayLine, type DriverConfig, type DriverEvent, type Logger, type PadDriver, type SignatureCallbackHandlers, type SignatureDisplayData, type SignatureEventHandler, type SignatureEventHandlerLive, type SignatureOutputOptions, type StartSignatureOptions };

package/dist/types.js

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+__export(types_exports, {
+  DEVICE_TYPE_MAPPINGS: () => DEVICE_TYPE_MAPPINGS
+});
+module.exports = __toCommonJS(types_exports);
+var DEVICE_TYPE_MAPPINGS = {
+  1: "Sigma USB",
+  2: "Sigma seriell",
+  5: "Zeta USB",
+  6: "Zeta seriell",
+  11: "Omega USB",
+  12: "Omega seriell",
+  15: "Gamma USB",
+  16: "Gamma seriell",
+  21: "Delta USB",
+  22: "Delta seriell",
+  23: "Delta IP",
+  31: "Alpha USB",
+  32: "Alpha seriell",
+  33: "Alpha IP"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEVICE_TYPE_MAPPINGS
+});
+//# sourceMappingURL=types.js.map