validation.gs1-check-digit

export function gs1CheckDigit(data: string): number

import { gs1CheckDigit } from "#fune/validation.gs1-check-digit@^1";

/**
 * The GS1 mod-10 check digit for `data`, the digits of a GS1 key without its
 * check digit. One rule serves every key length because the weights are
 * counted from the right: 3, 1, 3, 1 ... starting with the digit that will sit
 * next to the check digit. Counting from the left instead only works for
 * EAN-13 and the other even-length data strings.
 */
export function gs1CheckDigit(data: string): number {
  if (typeof data !== "string" || !/^[0-9]+$/.test(data)) {
    throw new RangeError(`GS1 data must be one or more ASCII digits, received ${JSON.stringify(data)}`);
  }
  let total = 0;
  let weight = 3;
  for (let i = data.length - 1; i >= 0; i--) {
    // Reducing as we go keeps the sum small for data of any length.
    total = (total + (data.charCodeAt(i) - 48) * weight) % 10;
    weight = weight === 3 ? 1 : 3;
  }
  return (10 - total) % 10;
}

export function isGs1CheckDigitValid(key: string): boolean

import { isGs1CheckDigitValid } from "#fune/validation.gs1-check-digit@^1";

import { gs1CheckDigit } from "./validation_gs1_check_digit_gs1_check_digit.ts";  ← gs1CheckDigit, another function of this group · built into the same file, even by a slim install

/**
 * Whether the last digit of `key` is the GS1 check digit of the digits before
 * it. Only the arithmetic: the length, the prefix and an all-zero key are the
 * caller's to judge. Validators answer rather than throw, so anything that is
 * not two or more ASCII digits is false.
 */
export function isGs1CheckDigitValid(key: string): boolean {
  if (typeof key !== "string" || !/^[0-9]{2,}$/.test(key)) return false;
  return gs1CheckDigit(key.slice(0, -1)) === key.charCodeAt(key.length - 1) - 48;
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the TypeScript package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add validation.gs1-check-digit

That builds the whole group. To build only what you call, and whatever it uses inside the group:

fune add validation.gs1-check-digit --only gs1CheckDigit

The manifest, vectors and README with only the TypeScript implementation. Install it without the registry with fune add ./validation.gs1-check-digit-1.0.0-typescript.fune, or fetch it from a terminal with fune pull validation.gs1-check-digit@1.0.0:typescript.

The whole function, every language, is one file too: validation.gs1-check-digit-1.0.0.fune, 15,242 bytes, sha256 f57294b4fe86f2e8ced3fffedc28f4fba3738cd0d9037d8ce207562cf69d30ca. It installs into a project of any language.

// fune: before validation.gs1-check-digit.gs1CheckDigit
// fune: before validation.gs1-check-digit.isGs1CheckDigitValid

// fune: after validation.gs1-check-digit.gs1CheckDigit
// fune: after validation.gs1-check-digit.isGs1CheckDigitValid

// fune: step validation.gs1-check-digit.<fn> after <n|label>

More from the author

## The rule

Weight the data digits 3, 1, 3, 1 ... starting from the rightmost and moving left, add them up, and the check digit is whatever brings the sum up to a multiple of ten: `(10 - sum mod 10) mod 10`. A sum that is already a multiple of ten gives 0, not 10.

Weighting from the right is what lets one rule serve every length, and it is the detail home-grown code gets wrong. An EAN-13's first digit is weighted 1, but a GTIN-8's, a UPC-A's and an SSCC's first digit is weighted 3, so code that always starts at the left with 1 is right only for keys with an even number of data digits.

GS1's worked example: the GTIN-13 data `629104150021` weighted from the right sums to 57, so the check digit is 3 and the GTIN is `6291041500213`. The SSCC data `37610425002123456` sums to 101, check digit 9. Both are vectors.

## Input

ASCII digits only, of any length (at least one data digit; at least two digits for a whole key). Spaces, hyphens and the `(00)`-style application identifiers printed on labels are not tidied away: strip them before calling, because what counts as a separator is the key's business, not the checksum's. Non-ASCII digits (Arabic-Indic, superscripts) are refused in every language.

- `gs1CheckDigit` throws on anything else, empty included, with `GS1 data must be one or more ASCII digits`: there is no digit to return. - `isGs1CheckDigitValid` answers `false` instead, as validators do.

## What it does not check

Only the arithmetic. It does not know which lengths a key may have, what a GS1 prefix means, or whether GS1 allocated the number. An all-zero key passes the arithmetic (its check digit is 0); `validation.gtin` refuses it as a GTIN, and any other key that should do the same says so itself. A passing key is well formed: every single mistyped digit and most adjacent transpositions (all except those of two digits differing by 5) change the check digit.

## Source

GS1 General Specifications, section 7.9 "Check digit calculation"; https://www.gs1.org/services/how-calculate-check-digit-manually

Files