@bars4j/core 0.0.0-stage → 0.7.1

package/README.md

@@ -1,3 +1,117 @@
-# Temporary Holding Version
+# Bars4J for Node.js / TypeScript (`@bars4j/core`)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A Node.js/TypeScript port of the [Bars4J](https://github.com/ronison/bars4j) barcode library,
+keeping the same characteristics and functionality.
+
+This package lives in the same repository as the Java implementation and shares its golden
+fixtures, so the two stay in sync. The port is being delivered in phases:
+
+| Phase | Scope | Status |
+|-------|-------|--------|
+| 1 | Core + SVG for all 20 linear (1D) formats | **done** |
+| 2 | 2D formats (QRCode, Data Matrix, PDF417, Aztec) + SVG | **done** |
+| 3 | Raster output (ARGB image + PNG) and optional canvas text | **done** |
+| 4 | Demos, CLI, packaging and CI | **done** |
+
+## Usage
+
+```ts
+import { BarcodeGenerator, encodePng } from "@bars4j/core";
+
+const svg = BarcodeGenerator.of("EAN13").toSvg("789100031550");
+
+// Raster: an opaque ARGB image (width, height, Int32Array pixels).
+const image = BarcodeGenerator.of("EAN13").toImage("789100031550");
+const png = encodePng(image); // Uint8Array, no native dependency required
+```
+
+The raster path is split in two:
+
+- **Geometry (dependency-free).** Bars and modules are rasterised directly into an
+  [`RasterImage`](src/render/raster-image.ts) — an opaque ARGB buffer matching the Java
+  `TYPE_INT_RGB` layout — and PNG export uses Node's built-in `zlib`. This path is
+  byte-for-byte identical to the Java `*.image.txt` goldens.
+- **Human-readable text (optional).** Drawing glyphs needs a font rasteriser, so it uses the
+  optional [`@napi-rs/canvas`](https://www.npmjs.com/package/@napi-rs/canvas) backend. Glyphs are
+  not guaranteed to be pixel-identical to the Java AWT output (only the bar geometry is), and
+  requesting text without the backend installed throws a descriptive error. Use
+  `canvasAvailable()` to probe, or disable the label via `LinearBarcodeFormat.withOptions`.
+
+`BarcodeGenerator.of("<format id>")` accepts any id registered in the `BarcodeRegistry`
+(case-insensitive):
+
+- 1D: `EAN13`, `EAN8`, `EAN5`, `UPCA`, `UPCE`, `CODABAR`, `CODE39`, `CODE39EXT`, `CODE93`,
+  `CODE93EXT`, `CODE128`, `CODE11`, `MSIPLESSEY`, `STANDARD2OF5`, `IATA2OF5`,
+  `INTERLEAVED2OF5`, `ITF14`, `MATRIX2OF5`, `DATALOGIC2OF5`, `POSTNET`.
+- 2D: `QRCODE`, `DATAMATRIX`, `PDF417`, `AZTEC`.
+
+## Running the tests
+
+Node.js 22.18+ runs the TypeScript sources directly (type stripping), so no build step is needed:
+
+```sh
+npm test          # conformance tests against the shared Java goldens
+npm run typecheck # type-check with tsc
+npm run check     # both
+```
+
+## Demos and CLI
+
+```sh
+npm run demo          # SVG + PNG for every registered format, into node/images/
+npm run demo:qrcode   # 2D showcase (bigger modules, all four 2D formats)
+
+# Command line (installed as the `bars4j` binary):
+bars4j EAN13 789100031550 > barcode.svg
+bars4j QRCODE "https://github.com/ronison/bars4j" --png qr.png --module-size 8
+bars4j --list
+```
+
+## Conformance
+
+The SVG output is verified byte-for-byte against the Java goldens stored in
+`../src/test/resources/golden`. For the 1D formats these are the shared `.svg` files produced by the
+Java build; for the 2D formats the module matrices and the end-to-end SVG documents live in
+`../src/test/resources/golden/matrix` and are generated from the (unmodified) Java implementation.
+The 1D raster geometry is additionally verified through the `*.image.txt` pixel fingerprints
+(SHA-256 of the ARGB pixels), which the Node port reproduces exactly. Every registered format is
+also smoke-tested for SVG and PNG output with the shared demo payloads.
+
+## Packaging
+
+The package ships the TypeScript sources (`src/`, `bin/`, `examples/`) and runs directly on
+Node.js 22.18+; there is no build step. Consumers therefore need Node.js 22.18+ (native type
+stripping) or a bundler that understands TypeScript; TypeScript projects may need
+`allowImportingTsExtensions` (or `moduleResolution: "bundler"`). The package contents are checked
+with `npm pack --dry-run` in CI.
+
+### Publishing to npm
+
+Publishing is automated by [`.github/workflows/node-publish.yml`](../.github/workflows/node-publish.yml),
+triggered when a GitHub release is published (aligned with the Maven workflow), when a `node-v*` tag
+is pushed, or manually. It runs the test suite first and then publishes with `--provenance`.
+
+Authentication picks one of two paths:
+
+- **Trusted publishing (recommended, no secret).** The npm package must already exist. Create it once
+  (e.g. publish a placeholder, or register `@bars4j/core` on npmjs.com), then on the package's
+  **Settings → Trusted Publisher** add a GitHub Actions publisher:
+  - Organization/User: `ronison`
+  - Repository: `bars4j`
+  - Workflow filename: `node-publish.yml`
+  - Environment: *(empty)*
+
+  With that configured, the workflow authenticates via OIDC (`id-token: write`).
+- **Classic token.** Add an `NPM_TOKEN` repository secret (npm *Automation*/granular token with
+  publish rights for `@bars4j` and 2FA bypass). The workflow uses it automatically when present.
+
+To validate the package locally before publishing:
+
+```sh
+npm publish --dry-run --access public
+```
+
+
+## License
+
+LGPL-2.1-or-later, inherited from the Java project. See the repository root `LICENSE`.

package/bin/bars4j.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { writeFileSync } from "node:fs";
+
+import {
+  BarcodeGenerator,
+  BarcodeRegistry,
+  encodePng,
+  linearDefaults,
+  LinearBarcodeFormat,
+  renderSpec,
+} from "../src/index.ts";
+
+/**
+ * Command-line interface for {@code @bars4j/core}.
+ *
+ * <pre>
+ * bars4j &lt;format&gt; &lt;text&gt; [--svg|--png FILE] [--module-size N] [--no-text]
+ * bars4j --list
+ * </pre>
+ */
+
+interface Options {
+  id: string;
+  text: string;
+  png?: string;
+  out?: string;
+  moduleSize: number;
+  noText: boolean;
+}
+
+function usage(message?: string): never {
+  if (message !== undefined) {
+    process.stderr.write(`bars4j: ${message}\n\n`);
+  }
+  process.stdout.write(
+    "Usage: bars4j <format> <text> [options]\n"
+      + "       bars4j --list\n\n"
+      + "Options:\n"
+      + "  --svg              emit the SVG to stdout (default)\n"
+      + "  --png <file>       write a PNG raster to <file>\n"
+      + "  --out <file>       write the SVG to <file> instead of stdout\n"
+      + "  --module-size <n>  module size in pixels for 2D formats (default 4)\n"
+      + "  --no-text          do not draw the human-readable text (1D formats)\n"
+      + "  --list             list the registered format ids\n",
+  );
+  process.exit(message === undefined ? 0 : 1);
+}
+
+function parse(argv: string[]): Options {
+  const positional: string[] = [];
+  let png: string | undefined;
+  let out: string | undefined;
+  let moduleSize = 4;
+  let noText = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--png":
+        png = argv[++i];
+        break;
+      case "--out":
+        out = argv[++i];
+        break;
+      case "--module-size":
+        moduleSize = Number(argv[++i]);
+        break;
+      case "--no-text":
+        noText = true;
+        break;
+      case "--svg":
+        break;
+      case "--list":
+        process.stdout.write(BarcodeRegistry.getInstance().ids().sort().join("\n") + "\n");
+        process.exit(0);
+        break;
+      default:
+        if (arg.startsWith("--")) {
+          usage(`unknown option ${arg}`);
+        }
+        positional.push(arg);
+    }
+  }
+
+  if (positional.length < 2) {
+    usage("missing <format> and <text>");
+  }
+  if (!Number.isInteger(moduleSize) || moduleSize <= 0) {
+    usage(`invalid --module-size ${moduleSize}`);
+  }
+  return { id: positional[0], text: positional[1], png, out, moduleSize, noText };
+}
+
+const options = parse(process.argv.slice(2));
+const spec = renderSpec(1, 70, 2.0, options.moduleSize, "#000000", "#ffffff");
+
+try {
+  const format = BarcodeRegistry.getInstance().get(options.id);
+  const bare = options.noText && format instanceof LinearBarcodeFormat;
+
+  const svg = bare
+    ? format.withOptions({ ...format.options(), showText: false }).toSvg(options.text, linearDefaults())
+    : BarcodeGenerator.of(options.id).with(spec).toSvg(options.text);
+
+  if (options.out !== undefined) {
+    writeFileSync(options.out, svg);
+    process.stderr.write(`bars4j: wrote ${options.out}\n`);
+  } else if (options.png === undefined) {
+    process.stdout.write(svg);
+  }
+
+  if (options.png !== undefined) {
+    const image = bare
+      ? format.withOptions({ ...format.options(), showText: false }).toImage(options.text, linearDefaults())
+      : BarcodeGenerator.of(options.id).with(spec).toImage(options.text);
+    writeFileSync(options.png, encodePng(image));
+    process.stderr.write(`bars4j: wrote ${options.png} (${image.width}x${image.height})\n`);
+  }
+} catch (error) {
+  usage(error instanceof Error ? error.message : String(error));
+}

package/examples/all-formats.ts

@@ -0,0 +1,24 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import { BarcodeGenerator, BarcodeRegistry, encodePng } from "../src/index.ts";
+import { rasterImage } from "./render.ts";
+import { sampleFor } from "./sample-content.ts";
+
+/**
+ * Generates an SVG and a PNG for every registered format, mirroring
+ * {@code org.bars4j.demo.SimpleDemo} in the Java project.
+ *
+ * <p>Run with {@code npm run demo} (optionally passing an output directory).
+ */
+const outDir = process.argv[2] ?? fileURLToPath(new URL("../images/", import.meta.url));
+mkdirSync(outDir, { recursive: true });
+
+for (const id of BarcodeRegistry.getInstance().ids()) {
+  const text = sampleFor(id);
+  writeFileSync(`${outDir}/${id}.svg`, BarcodeGenerator.of(id).toSvg(text));
+  writeFileSync(`${outDir}/${id}.png`, encodePng(rasterImage(id, text)));
+  console.log(`${id.padEnd(14)} "${text}" -> ${id}.svg / ${id}.png`);
+}
+
+console.log(`\nGenerated ${BarcodeRegistry.getInstance().ids().length} formats in ${outDir}`);

package/examples/qrcode-demo.ts

@@ -0,0 +1,44 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import { BarcodeGenerator, BarcodeRegistry, encodePng, renderSpec } from "../src/index.ts";
+import { rasterImage } from "./render.ts";
+
+/**
+ * Demonstrates the unified API, including the 2D formats, mirroring
+ * {@code org.bars4j.demo.QRCodeDemo} in the Java project.
+ *
+ * <p>Run with {@code npm run demo:qrcode} (optionally passing an output directory).
+ */
+const outDir = process.argv[2] ?? fileURLToPath(new URL("../images/", import.meta.url));
+mkdirSync(outDir, { recursive: true });
+
+console.log(`Registered formats: ${BarcodeRegistry.getInstance().ids().join(", ")}`);
+
+const text = "https://github.com/ronison/bars4j";
+
+// A QRCode rendered with the default settings (error correction level M, module size 4).
+writeFileSync(`${outDir}/QRCode.svg`, BarcodeGenerator.of("QRCODE").toSvg(text));
+writeFileSync(`${outDir}/QRCode.png`, encodePng(rasterImage("QRCODE", text)));
+
+// A larger QRCode: bigger modules.
+const big = renderSpec(1, 70, 2.0, 8, "#000000", "#ffffff");
+const bigImage = BarcodeGenerator.of("QRCODE").with(big).toImage(text);
+writeFileSync(`${outDir}/QRCode-big.png`, encodePng(bigImage));
+console.log(`QRCODE: ${bigImage.width}x${bigImage.height}px -> QRCode-big.png`);
+
+// The same unified entry point works for the 1D formats too.
+writeFileSync(
+  `${outDir}/EAN13-from-new-api.svg`,
+  BarcodeGenerator.of("EAN13").toSvg("789100031550"),
+);
+
+// The remaining 2D formats, rendered through the same API.
+for (const id of ["DATAMATRIX", "PDF417", "AZTEC"]) {
+  writeFileSync(`${outDir}/${id}.svg`, BarcodeGenerator.of(id).toSvg(text));
+  const image = rasterImage(id, text);
+  writeFileSync(`${outDir}/${id}.png`, encodePng(image));
+  console.log(`${id}: ${image.width}x${image.height}px -> ${id}.svg / ${id}.png`);
+}
+
+console.log(`\nWritten to ${outDir}`);

package/examples/render.ts

@@ -0,0 +1,25 @@
+import {
+  BarcodeGenerator,
+  BarcodeRegistry,
+  canvasAvailable,
+  linearDefaults,
+  LinearBarcodeFormat,
+  matrixDefaults,
+  type RasterImage,
+} from "../src/index.ts";
+
+/**
+ * Renders the raster image for a format without requiring the optional canvas backend: when it is
+ * not installed, the human-readable text is disabled for the linear formats (the bar geometry is
+ * identical either way).
+ */
+export function rasterImage(formatId: string, text: string): RasterImage {
+  if (canvasAvailable()) {
+    return BarcodeGenerator.of(formatId).toImage(text);
+  }
+  const format = BarcodeRegistry.getInstance().get(formatId);
+  if (format instanceof LinearBarcodeFormat) {
+    return format.withOptions({ ...format.options(), showText: false }).toImage(text, linearDefaults());
+  }
+  return format.toImage(text, matrixDefaults());
+}

package/examples/sample-content.ts

@@ -0,0 +1,35 @@
+/**
+ * Sample payloads for the demos, mirroring {@code org.bars4j.demo.SampleContent} in the Java
+ * project (and the codes used by the golden tests).
+ */
+export const SAMPLES: ReadonlyMap<string, string> = new Map<string, string>([
+  ["EAN13", "789100031550"],
+  ["EAN8", "9788515"],
+  ["EAN5", "54495"],
+  ["UPCA", "07567816415"],
+  ["UPCE", "0756785"],
+  ["CODABAR", "97885150040-85"],
+  ["CODE39", "BARS4J-39"],
+  ["CODE39EXT", "Bars4J-39Ext"],
+  ["CODE93", "BARS4J-93"],
+  ["CODE93EXT", "Bars4J-93Ext"],
+  ["CODE128", "Bars4J-128"],
+  ["CODE11", "9788515004041"],
+  ["MSIPLESSEY", "9788515004041"],
+  ["STANDARD2OF5", "978851500404"],
+  ["IATA2OF5", "978851500404"],
+  ["MATRIX2OF5", "123456"],
+  ["DATALOGIC2OF5", "123456"],
+  ["INTERLEAVED2OF5", "9876543210921"],
+  ["ITF14", "1540014128876"],
+  ["POSTNET", "805365961"],
+  ["QRCODE", "https://github.com/ronison/bars4j"],
+  ["DATAMATRIX", "https://github.com/ronison/bars4j"],
+  ["PDF417", "https://github.com/ronison/bars4j"],
+  ["AZTEC", "https://github.com/ronison/bars4j"],
+]);
+
+/** Returns a sample that encodes with the given format id, or {@code "Bars4J"} as fallback. */
+export function sampleFor(formatId: string): string {
+  return SAMPLES.get(formatId.toUpperCase()) ?? "Bars4J";
+}

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@bars4j/core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.1",
+  "description": "Node.js/TypeScript port of the Bars4J barcode library (1D + 2D, SVG and raster).",
+  "type": "module",
+  "license": "LGPL-2.1-or-later",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "bars4j": "./bin/bars4j.ts"
+  },
+  "sideEffects": false,
+  "files": [
+    "src",
+    "bin",
+    "examples",
+    "README.md"
+  ],
+  "keywords": [
+    "barcode",
+    "barcodes",
+    "ean13",
+    "ean8",
+    "upca",
+    "upce",
+    "code128",
+    "code39",
+    "itf14",
+    "postnet",
+    "qrcode",
+    "datamatrix",
+    "pdf417",
+    "aztec",
+    "svg",
+    "png"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ronison/bars4j.git",
+    "directory": "node"
+  },
+  "homepage": "https://github.com/ronison/bars4j",
+  "bugs": {
+    "url": "https://github.com/ronison/bars4j/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test",
+    "test:golden": "node --test test/",
+    "typecheck": "tsc --noEmit",
+    "check": "npm run typecheck && npm test",
+    "demo": "node examples/all-formats.ts",
+    "demo:qrcode": "node examples/qrcode-demo.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "typescript": "^7.0.2"
+  },
+  "optionalDependencies": {
+    "@napi-rs/canvas": "^1.1.0"
+  }
+}

package/src/api/barcode-generator.ts

@@ -0,0 +1,54 @@
+import type { FormatSpec } from "../format/format-spec.ts";
+import type { BarcodeFormat } from "../format/barcode-format.ts";
+import { BarcodeRegistry } from "../format/barcode-registry.ts";
+import type { RasterImage } from "../render/raster-image.ts";
+import { SymbolKind } from "../symbol/symbol-kind.ts";
+import { linearDefaults, matrixDefaults, type RenderSpec } from "../render/render-spec.ts";
+
+/**
+ * Unified entry point to generate any registered barcode format (1D or 2D).
+ *
+ * <pre>{@code
+ * const svg = BarcodeGenerator.of("EAN13").toSvg("789100031550");
+ * }</pre>
+ *
+ * Port of {@code org.bars4j.api.BarcodeGenerator}.
+ */
+export class BarcodeGenerator {
+  private readonly barcodeFormat: BarcodeFormat;
+  private readonly renderSpec: RenderSpec;
+
+  private constructor(barcodeFormat: BarcodeFormat, renderSpec: RenderSpec) {
+    this.barcodeFormat = barcodeFormat;
+    this.renderSpec = renderSpec;
+  }
+
+  static of(formatId: string): BarcodeGenerator {
+    const format = BarcodeRegistry.getInstance().get(formatId);
+    const spec = format.spec().kind === SymbolKind.MATRIX
+      ? matrixDefaults()
+      : linearDefaults();
+    return new BarcodeGenerator(format, spec);
+  }
+
+  with(renderSpec: RenderSpec): BarcodeGenerator {
+    return new BarcodeGenerator(this.barcodeFormat, renderSpec);
+  }
+
+  format(): FormatSpec {
+    return this.barcodeFormat.spec();
+  }
+
+  /** Raster output: renders the symbol to a {@link RasterImage} (opaque ARGB pixels). */
+  toImage(text: string): RasterImage {
+    return this.barcodeFormat.toImage(text, this.renderSpec);
+  }
+
+  toSvg(text: string): string {
+    return this.barcodeFormat.toSvg(text, this.renderSpec);
+  }
+
+  checkSum(text: string): string {
+    return this.barcodeFormat.checkSum(text);
+  }
+}

package/src/encode/api/barcode-encoder.ts

@@ -0,0 +1,35 @@
+import type { BarcodeSymbol } from "../../symbol/barcode-symbol.ts";
+import type { LinearSymbol } from "../../symbol/linear-symbol.ts";
+
+/**
+ * Encodes text into a {@link BarcodeSymbol}.
+ *
+ * Port of {@code org.bars4j.encode.api.BarcodeEncoder}.
+ */
+export interface BarcodeEncoder<S extends BarcodeSymbol> {
+  encode(text: string): S;
+
+  /**
+   * Computes the check digit/sum for the given text. Formats without an external check value
+   * (e.g. Code128 computes it internally) may return an empty string.
+   */
+  computeCheckSum(text: string): string;
+}
+
+/**
+ * Encoder of linear (1D) symbols.
+ *
+ * Port of {@code org.bars4j.encode.api.LinearEncoder}.
+ */
+export interface LinearEncoder extends BarcodeEncoder<LinearSymbol> {
+  /**
+   * Length of a complete symbol including its external check digit, or {@code undefined}/-1 when the
+   * format is variable length or has no external check value.
+   */
+  completeLength?(): number;
+}
+
+/** Effective complete length of a linear encoder (mirrors the Java default of -1). */
+export function completeLength(encoder: LinearEncoder): number {
+  return encoder.completeLength ? encoder.completeLength() : -1;
+}

package/src/encode/api/barcode-exception.ts

@@ -0,0 +1,11 @@
+/**
+ * Base exception for all barcode encoding/decoding failures.
+ *
+ * Port of {@code org.bars4j.encode.api.BarcodeException}.
+ */
+export class BarcodeException extends Error {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options);
+    this.name = "BarcodeException";
+  }
+}

package/src/encode/api/invalid-symbol-exception.ts

@@ -0,0 +1,14 @@
+import { BarcodeException } from "./barcode-exception.ts";
+
+/**
+ * Thrown when the input cannot be represented by the target barcode format
+ * (wrong length, unsupported characters, value out of range, ...).
+ *
+ * Port of {@code org.bars4j.encode.api.InvalidSymbolException}.
+ */
+export class InvalidSymbolException extends BarcodeException {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options);
+    this.name = "InvalidSymbolException";
+  }
+}

package/src/encode/api/matrix-encoder.ts

@@ -0,0 +1,9 @@
+import type { MatrixSymbol } from "../../symbol/matrix-symbol.ts";
+import type { BarcodeEncoder } from "./barcode-encoder.ts";
+
+/**
+ * Encoder of matrix (2D) symbols, such as QRCode.
+ *
+ * Port of {@code org.bars4j.encode.api.MatrixEncoder}.
+ */
+export interface MatrixEncoder extends BarcodeEncoder<MatrixSymbol> {}

package/src/encode/api/unsupported-text-exception.ts

@@ -0,0 +1,14 @@
+import { InvalidSymbolException } from "./invalid-symbol-exception.ts";
+
+/**
+ * Thrown when the input text is not supported by the selected encoding mode
+ * (e.g. non-numeric text on a numeric-only barcode).
+ *
+ * Port of {@code org.bars4j.encode.api.UnsupportedTextException}.
+ */
+export class UnsupportedTextException extends InvalidSymbolException {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options);
+    this.name = "UnsupportedTextException";
+  }
+}

package/src/encode/linear/codabar-encoder.ts

@@ -0,0 +1,60 @@
+import { BitSemantics } from "../../format/bit-semantics.ts";
+import type { LinearSymbol } from "../../symbol/linear-symbol.ts";
+import type { LinearEncoder } from "../api/barcode-encoder.ts";
+import { InvalidSymbolException } from "../api/invalid-symbol-exception.ts";
+import { symbol } from "./linear-bits.ts";
+
+const CODES_WIDTH = [
+  "0000011", "0000110", "0001001", "1100000", "0010010",
+  "1000010", "0100001", "0100100", "0110000", "1001000",
+  "0001100", "0011000", "1000101", "1010001", "1010100",
+  "0011111", "0011010", "0001011", "0101001", "0001110",
+];
+
+const INTER_CHAR = "0";
+const START_CHAR_A = 16;
+const STOP_CHAR_ASTERISC = 18;
+
+/**
+ * Native Codabar encoder. Ported from the legacy {@code CodabarEncoder} (default start 'A',
+ * stop '*').
+ */
+export class CodabarEncoder implements LinearEncoder {
+  encode(text: string): LinearSymbol {
+    if (text.length < 1) {
+      throw new InvalidSymbolException(`[Codabar] Invalid text length (${text.length}).`);
+    }
+    let bits = CODES_WIDTH[START_CHAR_A];
+    for (let i = 0; i < text.length; i++) {
+      bits += INTER_CHAR;
+      bits += CODES_WIDTH[getCharIndex(text.charAt(i))];
+    }
+    bits += INTER_CHAR;
+    bits += CODES_WIDTH[STOP_CHAR_ASTERISC];
+    return symbol(bits, BitSemantics.WIDE_NARROW_ALTERNATING);
+  }
+
+  computeCheckSum(_text: string): string {
+    return "";
+  }
+}
+
+function getCharIndex(c: string): number {
+  const code = c.charCodeAt(0);
+  if (c >= "0" && c <= "9") {
+    return code - 48;
+  } else if (c === "-") {
+    return 10;
+  } else if (c === "$") {
+    return 11;
+  } else if (c === ":") {
+    return 12;
+  } else if (c === "/") {
+    return 13;
+  } else if (c === ".") {
+    return 14;
+  } else if (c === "+") {
+    return 15;
+  }
+  throw new InvalidSymbolException(`[Codabar] The text contains not suported chars (${c}).`);
+}