@bottlebooks/valid-values 10.49.0 → 10.50.0

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [10.50.0](https://github.com/bottlebooks/bottlebooks/compare/@bottlebooks/valid-values@10.49.0...@bottlebooks/valid-values@10.50.0) (2025-04-14)
+
+### Bug Fixes
+
+- add carbohydrateSugarsIsNegligible flag ([ec15b6a](https://github.com/bottlebooks/bottlebooks/commit/ec15b6a15a27d5cf2a9f89d4f7c3360a2477028b))
+- error building valid values because of missing id ([70c018a](https://github.com/bottlebooks/bottlebooks/commit/70c018a7ab9bd3493968874f889bcc79e17fc144))
+- import and load translations ([d8591ae](https://github.com/bottlebooks/bottlebooks/commit/d8591ae25b44847601062d025d840b4f96d60288))
+- vitest error - expect cannot be wrapped ([747915a](https://github.com/bottlebooks/bottlebooks/commit/747915ab883b8fede0c778d667f266973694494f))
+
+### Features
+
+- add coverage to carbs is negligible and sugar not ([0334823](https://github.com/bottlebooks/bottlebooks/commit/0334823c865b5835137f5e19043de9abb59aad3f))
+- add coverage to negligible sugars ([31c5cfd](https://github.com/bottlebooks/bottlebooks/commit/31c5cfd8fc5c0f0cc811208af53980523a0a01f5))
+- handle carbohydrateSugarsIsNegligible to build simplified declaration ([d926e8b](https://github.com/bottlebooks/bottlebooks/commit/d926e8b9252bf8be4048e510f25e22169ddbfdb3))
+
 # [10.49.0](https://github.com/bottlebooks/bottlebooks/compare/@bottlebooks/valid-values@10.48.1...@bottlebooks/valid-values@10.49.0) (2025-03-18)
 
 ### Features

package/dist/validValues/ingredient/ingredient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ingredient.d.ts","sourceRoot":"","sources":["../../../src/validValues/ingredient/ingredient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAM1E,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,mBAAmB,CAAC;AAUhF,UAAU,UACR,SAAQ,oBAAoB,EAC1B,sCAAsC;CAAG;AA4B7C,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAssDV,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,cAAc,CAAC;AAExD,eAAO,MAAM,aAAa,ovDAUzB,CAAC;AAEF,eAAe,cAAc,CAAC"}
+{"version":3,"file":"ingredient.d.ts","sourceRoot":"","sources":["../../../src/validValues/ingredient/ingredient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAM1E,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,mBAAmB,CAAC;AAUhF,UAAU,UACR,SAAQ,oBAAoB,EAC1B,sCAAsC;CAAG;AA4B7C,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwsDV,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,cAAc,CAAC;AAExD,eAAO,MAAM,aAAa,ovDAUzB,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/validValues/ingredient/ingredient.js

@@ -1328,7 +1328,8 @@ var allIngredients = _objectSpread(_objectSpread({}, _deprecatedIngredient["defa
       synonymDescription:
       /*i18n*/
       {
-        id: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.'
+        id: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.',
+        message: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.'
       }
     }
   }),
@@ -1375,7 +1376,8 @@ var allIngredients = _objectSpread(_objectSpread({}, _deprecatedIngredient["defa
       synonymDescription:
       /*i18n*/
       {
-        id: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.'
+        id: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.',
+        message: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.'
       }
     }
   }),

package/dist/validValues/otherTranslations/simplifiedDeclarationStatement.d.ts

@@ -1,9 +1,10 @@
-export declare function simplifiedDeclarationStatement({ fatIsNegligible, proteinIsNegligible, saltIsNegligible, carbohydratesIsNegligible, showSimplifiedTable, }: {
+export declare function simplifiedDeclarationStatement({ fatIsNegligible, proteinIsNegligible, saltIsNegligible, carbohydratesIsNegligible, carbohydrateSugarsIsNegligible, showSimplifiedTable, }: {
     fatIsNegligible?: boolean;
     proteinIsNegligible?: boolean;
     saltIsNegligible?: boolean;
     saturatedFatIsNegligible?: boolean;
     carbohydratesIsNegligible?: boolean;
+    carbohydrateSugarsIsNegligible?: boolean;
     showSimplifiedTable?: boolean;
 }, { language }: {
     language: string;

package/dist/validValues/otherTranslations/simplifiedDeclarationStatement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplifiedDeclarationStatement.d.ts","sourceRoot":"","sources":["../../../src/validValues/otherTranslations/simplifiedDeclarationStatement.ts"],"names":[],"mappings":"AAEA,wBAAgB,8BAA8B,CAC5C,EACE,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,yBAAyB,EACzB,mBAAmB,GACpB,EAAE;IACD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,EACD,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,UAsBnC"}
+{"version":3,"file":"simplifiedDeclarationStatement.d.ts","sourceRoot":"","sources":["../../../src/validValues/otherTranslations/simplifiedDeclarationStatement.ts"],"names":[],"mappings":"AAEA,wBAAgB,8BAA8B,CAC5C,EACE,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,yBAAyB,EACzB,8BAA8B,EAC9B,mBAAmB,GACpB,EAAE;IACD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,8BAA8B,CAAC,EAAE,OAAO,CAAC;IACzC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,EACD,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,UAuBnC"}

package/dist/validValues/otherTranslations/simplifiedDeclarationStatement.js

@@ -12,6 +12,7 @@ function simplifiedDeclarationStatement(_ref, _ref2) {
       proteinIsNegligible = _ref.proteinIsNegligible,
       saltIsNegligible = _ref.saltIsNegligible,
       carbohydratesIsNegligible = _ref.carbohydratesIsNegligible,
+      carbohydrateSugarsIsNegligible = _ref.carbohydrateSugarsIsNegligible,
       showSimplifiedTable = _ref.showSimplifiedTable;
   var language = _ref2.language;
   if (!language) throw new Error('required_param:language');
@@ -20,6 +21,7 @@ function simplifiedDeclarationStatement(_ref, _ref2) {
     language: language,
     fatIsNegligible: fatIsNegligible,
     carbohydratesIsNegligible: carbohydratesIsNegligible,
+    carbohydrateSugarsIsNegligible: carbohydrateSugarsIsNegligible,
     proteinIsNegligible: proteinIsNegligible,
     saltIsNegligible: saltIsNegligible
   });
@@ -40,13 +42,14 @@ function getSimplifiedDeclarationItemsText(_ref3) {
       fatIsNegligible = _ref3.fatIsNegligible,
       proteinIsNegligible = _ref3.proteinIsNegligible,
       saltIsNegligible = _ref3.saltIsNegligible,
-      carbohydratesIsNegligible = _ref3.carbohydratesIsNegligible;
+      carbohydratesIsNegligible = _ref3.carbohydratesIsNegligible,
+      carbohydrateSugarsIsNegligible = _ref3.carbohydrateSugarsIsNegligible;
   // fat and saturates
   var fatTranslation = fatIsNegligible ? (0, _translate.translate)('simplifiedDeclaration.fat', language) : null;
   var saturatedFatTranslation = fatIsNegligible ? (0, _translate.translate)('simplifiedDeclaration.saturatedFat', language) : null; // Carbohydrate and sugar
 
   var carbohidratesTranslation = carbohydratesIsNegligible ? (0, _translate.translate)('simplifiedDeclaration.carbohydrates', language) : null;
-  var carbohidrateSugarsTranslation = carbohydratesIsNegligible ? (0, _translate.translate)('simplifiedDeclaration.carbohydrateSugars', language) : null;
+  var carbohidrateSugarsTranslation = carbohydrateSugarsIsNegligible ? (0, _translate.translate)('simplifiedDeclaration.carbohydrateSugars', language) : null;
   var proteinTranslation = proteinIsNegligible ? (0, _translate.translate)('simplifiedDeclaration.protein', language) : null;
   var saltTranslation = saltIsNegligible ? (0, _translate.translate)('simplifiedDeclaration.salt', language) : null;
   var simplifiedDeclarationItems = [fatTranslation, saturatedFatTranslation, carbohidratesTranslation, carbohidrateSugarsTranslation, proteinTranslation, saltTranslation].filter(Boolean); // Use "en-GB" instead of "en" as language, because of the 'Oxford comma, Ex:

package/dist/validValues/otherTranslations/simplifiedDeclarationStatement.test.js

@@ -6,11 +6,15 @@ var _simplifiedDeclarationStatement = require("./simplifiedDeclarationStatement"
 
 var _plurals = require("make-plural/plurals");
 
-var _core = require("@lingui/core");
+var _de = require("./locales/de");
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+var _sk = require("./locales/sk");
 
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+var _fr = require("./locales/fr");
+
+var _en = require("./locales/en");
+
+var _core = require("@lingui/core");
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -18,15 +22,19 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
 var falsy = {
   fatIsNegligible: false,
   saltIsNegligible: false,
   proteinIsNegligible: false,
   carbohydratesIsNegligible: false,
+  carbohydrateSugarsIsNegligible: false,
   showSimplifiedTable: true
 };
-
-var loadLocales = function loadLocales() {
+(0, _vitest.beforeEach)(function () {
   _core.i18n.loadLocaleData('de', {
     plurals: _plurals.de
   });
@@ -43,34 +51,52 @@ var loadLocales = function loadLocales() {
     plurals: _plurals.en
   });
 
-  console.log('messages loaded for en,de');
-};
+  _core.i18n.load('de', _de.messages);
 
-(0, _vitest.beforeEach)(function () {
-  loadLocales();
+  _core.i18n.load('sk', _sk.messages);
+
+  _core.i18n.load('fr', _fr.messages);
+
+  _core.i18n.load('en', _en.messages);
 });
 (0, _vitest.afterEach)(function () {
-  loadLocales();
+  _core.i18n.loadLocaleData('de', {
+    plurals: undefined
+  });
+
+  _core.i18n.loadLocaleData('sk', {
+    plurals: undefined
+  });
+
+  _core.i18n.loadLocaleData('fr', {
+    plurals: undefined
+  });
+
+  _core.i18n.loadLocaleData('en', {
+    plurals: undefined
+  });
+
+  _core.i18n.load('de', {});
+
+  _core.i18n.load('sk', {});
+
+  _core.i18n.load('fr', {});
+
+  _core.i18n.load('en', {});
 });
 (0, _vitest.describe)('simplifiedDeclarationStatement', function () {
-  function _expect(o, opt, s) {
-    var statement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), o), _objectSpread({
-      language: 'en'
-    }, opt));
-    console.log('simplifiedDeclarationStatement:', statement);
-    return (0, _vitest.expect)(statement).toMatchInlineSnapshot(s);
-  }
-
   (0, _vitest.test)('simplifiedDeclaration.empty', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+    var statement;
     return regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _expect({}, {
+            statement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread({}, falsy), {
               language: 'en'
-            }, '""');
+            });
+            (0, _vitest.expect)(statement).toMatchInlineSnapshot('""');
 
-          case 1:
+          case 2:
           case "end":
             return _context.stop();
         }
@@ -78,17 +104,19 @@ var loadLocales = function loadLocales() {
     }, _callee);
   })));
   (0, _vitest.test)('simplifiedDeclaration.fat', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+    var statement;
     return regeneratorRuntime.wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            _expect({
+            statement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
               fatIsNegligible: true
-            }, {
+            }), {
               language: 'en'
-            }, '"<span>Contains negligible amounts of fat and saturates.</span>"');
+            });
+            (0, _vitest.expect)(statement).toMatchInlineSnapshot('"<span>Contains negligible amounts of fat and saturates.</span>"');
 
-          case 1:
+          case 2:
           case "end":
             return _context2.stop();
         }
@@ -96,18 +124,20 @@ var loadLocales = function loadLocales() {
     }, _callee2);
   })));
   (0, _vitest.test)('simplifiedDeclaration.fat.protein', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
+    var statement;
     return regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            _expect({
+            statement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
               fatIsNegligible: true,
               proteinIsNegligible: true
-            }, {
+            }), {
               language: 'en'
-            }, '"<span>Contains negligible amounts of fat, saturates and protein.</span>"');
+            });
+            (0, _vitest.expect)(statement).toMatchInlineSnapshot('"<span>Contains negligible amounts of fat, saturates and protein.</span>"');
 
-          case 1:
+          case 2:
           case "end":
             return _context3.stop();
         }
@@ -115,82 +145,164 @@ var loadLocales = function loadLocales() {
     }, _callee3);
   })));
   (0, _vitest.test)('simplifiedDeclaration.fat.salt', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4() {
+    var statement;
     return regeneratorRuntime.wrap(function _callee4$(_context4) {
       while (1) {
         switch (_context4.prev = _context4.next) {
           case 0:
-            _expect({
+            statement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
               fatIsNegligible: true,
               saltIsNegligible: true
-            }, {
+            }), {
               language: 'en'
-            }, '"<span>Contains negligible amounts of fat, saturates and salt.</span>"');
+            });
+            (0, _vitest.expect)(statement).toMatchInlineSnapshot('"<span>Contains negligible amounts of fat, saturates and salt.</span>"');
 
-          case 1:
+          case 2:
           case "end":
             return _context4.stop();
         }
       }
     }, _callee4);
   })));
-  (0, _vitest.test)('simplifiedDeclaration.fat.protein.carbohydrates', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5() {
+  (0, _vitest.test)('simplifiedDeclaration.fat.protein.carbohydrates.sugars', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5() {
+    var enStatement, frStatement;
     return regeneratorRuntime.wrap(function _callee5$(_context5) {
       while (1) {
         switch (_context5.prev = _context5.next) {
           case 0:
-            _expect({
+            enStatement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
               fatIsNegligible: true,
               proteinIsNegligible: true,
-              carbohydratesIsNegligible: true
-            }, {
+              carbohydratesIsNegligible: true,
+              carbohydrateSugarsIsNegligible: true
+            }), {
               language: 'en'
-            }, '"<span>Contains negligible amounts of fat, saturates, carbohydrate, sugars and protein.</span>"');
-
-            _expect({
+            });
+            (0, _vitest.expect)(enStatement).toMatchInlineSnapshot('"<span>Contains negligible amounts of fat, saturates, carbohydrate, sugars and protein.</span>"');
+            frStatement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
               fatIsNegligible: true,
               proteinIsNegligible: true,
-              carbohydratesIsNegligible: true
-            }, {
+              carbohydratesIsNegligible: true,
+              carbohydrateSugarsIsNegligible: true
+            }), {
               language: 'fr'
-            }, '"<span>Contient des quantités négligeables de matières grasses, acides gras saturés, glucides, sucres et protéines.</span>"');
+            });
+            (0, _vitest.expect)(frStatement).toMatchInlineSnapshot('"<span>Contient des quantités négligeables de matières grasses, acides gras saturés, glucides, sucres et protéines.</span>"');
 
-          case 2:
+          case 4:
           case "end":
             return _context5.stop();
         }
       }
     }, _callee5);
   })));
-  (0, _vitest.test)('simplifiedDeclaration.protein', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6() {
+  (0, _vitest.test)('simplifiedDeclaration.fat.protein.carbohydrates', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6() {
+    var enStatement, frStatement;
     return regeneratorRuntime.wrap(function _callee6$(_context6) {
       while (1) {
         switch (_context6.prev = _context6.next) {
           case 0:
-            _expect({
+            enStatement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
+              fatIsNegligible: true,
+              proteinIsNegligible: true,
+              carbohydratesIsNegligible: true
+            }), {
+              language: 'en'
+            });
+            (0, _vitest.expect)(enStatement).toMatchInlineSnapshot('"<span>Contains negligible amounts of fat, saturates, carbohydrate and protein.</span>"');
+            frStatement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
+              fatIsNegligible: true,
+              proteinIsNegligible: true,
+              carbohydratesIsNegligible: true
+            }), {
+              language: 'fr'
+            });
+            (0, _vitest.expect)(frStatement).toMatchInlineSnapshot('"<span>Contient des quantités négligeables de matières grasses, acides gras saturés, glucides et protéines.</span>"');
+
+          case 4:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  })));
+  (0, _vitest.test)('simplifiedDeclaration.fat.protein.sugars', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7() {
+    var statement;
+    return regeneratorRuntime.wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            statement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
+              fatIsNegligible: true,
+              proteinIsNegligible: true,
+              carbohydrateSugarsIsNegligible: true
+            }), {
+              language: 'en'
+            });
+            (0, _vitest.expect)(statement).toMatchInlineSnapshot('"<span>Contains negligible amounts of fat, saturates, sugars and protein.</span>"');
+
+          case 2:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee7);
+  })));
+  (0, _vitest.test)('simplifiedDeclaration.sugars', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee8() {
+    var statement;
+    return regeneratorRuntime.wrap(function _callee8$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            statement = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
+              carbohydrateSugarsIsNegligible: true
+            }), {
+              language: 'en'
+            });
+            (0, _vitest.expect)(statement).toMatchInlineSnapshot('"<span>Contains negligible amounts of sugars.</span>"');
+
+          case 2:
+          case "end":
+            return _context8.stop();
+        }
+      }
+    }, _callee8);
+  })));
+  (0, _vitest.test)('simplifiedDeclaration.protein', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee9() {
+    var statement1, statement2, statement3;
+    return regeneratorRuntime.wrap(function _callee9$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            statement1 = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
               proteinIsNegligible: true
-            }, {
+            }), {
               language: 'sk'
-            }, '"<span>Obsahuje zanedbateľné množstvá bielkovín.</span>"');
-
-            _expect({
+            });
+            (0, _vitest.expect)(statement1).toMatchInlineSnapshot('"<span>Obsahuje zanedbateľné množstvá bielkovín.</span>"');
+            statement2 = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
               carbohydratesIsNegligible: true,
+              carbohydrateSugarsIsNegligible: true,
               proteinIsNegligible: true,
               saltIsNegligible: true
-            }, {
+            }), {
               language: 'sk'
-            }, '"<span>Obsahuje zanedbateľné množstvá sacharidov, cukrov, bielkovín a soli.</span>"');
-
-            _expect({
-              carbohydratesIsNegligible: true
-            }, {
+            });
+            (0, _vitest.expect)(statement2).toMatchInlineSnapshot('"<span>Obsahuje zanedbateľné množstvá sacharidov, cukrov, bielkovín a soli.</span>"');
+            statement3 = (0, _simplifiedDeclarationStatement.simplifiedDeclarationStatement)(_objectSpread(_objectSpread({}, falsy), {}, {
+              carbohydratesIsNegligible: true,
+              carbohydrateSugarsIsNegligible: true
+            }), {
               language: 'en'
-            }, '"<span>Contains negligible amounts of carbohydrate and sugars.</span>"');
+            });
+            (0, _vitest.expect)(statement3).toMatchInlineSnapshot('"<span>Contains negligible amounts of carbohydrate and sugars.</span>"');
 
-          case 3:
+          case 6:
           case "end":
-            return _context6.stop();
+            return _context9.stop();
         }
       }
-    }, _callee6);
+    }, _callee9);
   })));
 });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bottlebooks/valid-values",
   "description": "The Bottlebooks lookup values, defined globally.",
   "private": false,
-  "version": "10.49.0",
+  "version": "10.50.0",
   "type": "commonjs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,5 +37,5 @@
   "dependencies": {
     "@lingui/core": "3.14.0"
   },
-  "gitHead": "b29a9f07ab8b1dcc1a3aef3f7a4381fde5edface"
+  "gitHead": "7c9df2824e0f9620c84f049fbf6d549325d8b9b5"
 }

package/src/validValues/ingredient/ingredient.ts

@@ -1426,6 +1426,7 @@ const allIngredients = {
       ],
       isHiddenInMainList: true,
       synonymDescription: defineMessage({
+        id: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.',
         message:
           'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.',
       }),
@@ -1483,6 +1484,7 @@ const allIngredients = {
       ],
       isHiddenInMainList: true,
       synonymDescription: defineMessage({
+        id: 'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.',
         message:
           'Bolding the entire term many not be accepted in all countries. Bottlebooks recommends only bolding the allergen.',
       }),

package/src/validValues/otherTranslations/simplifiedDeclarationStatement.test.ts

@@ -1,125 +1,206 @@
 import { describe, expect, test, beforeEach, afterEach } from 'vitest';
 import { simplifiedDeclarationStatement } from './simplifiedDeclarationStatement';
 import { de, en, sk, fr } from 'make-plural/plurals';
+import { messages as messagesDe } from './locales/de';
+import { messages as messagesSk } from './locales/sk';
+import { messages as messagesFr } from './locales/fr';
+import { messages as messagesEn } from './locales/en';
 import { i18n } from '@lingui/core';
 const falsy = {
   fatIsNegligible: false,
   saltIsNegligible: false,
   proteinIsNegligible: false,
   carbohydratesIsNegligible: false,
+  carbohydrateSugarsIsNegligible: false,
   showSimplifiedTable: true,
 };
-const loadLocales = () => {
+
+beforeEach(() => {
   i18n.loadLocaleData('de', { plurals: de });
   i18n.loadLocaleData('sk', { plurals: sk });
   i18n.loadLocaleData('fr', { plurals: fr });
   i18n.loadLocaleData('en', { plurals: en });
-  console.log('messages loaded for en,de');
-};
-beforeEach(() => {
-  loadLocales();
+  i18n.load('de', messagesDe);
+  i18n.load('sk', messagesSk);
+  i18n.load('fr', messagesFr);
+  i18n.load('en', messagesEn);
 });
 
 afterEach(() => {
-  loadLocales();
+  i18n.loadLocaleData('de', { plurals: undefined });
+  i18n.loadLocaleData('sk', { plurals: undefined });
+  i18n.loadLocaleData('fr', { plurals: undefined });
+  i18n.loadLocaleData('en', { plurals: undefined });
+  i18n.load('de', {});
+  i18n.load('sk', {});
+  i18n.load('fr', {});
+  i18n.load('en', {});
 });
+
 describe('simplifiedDeclarationStatement', () => {
-  function _expect(
-    o: {
-      fatIsNegligible?: boolean | undefined;
-      proteinIsNegligible?: boolean | undefined;
-      saltIsNegligible?: boolean | undefined;
-      carbohydratesIsNegligible?: boolean | undefined;
-      saturatedFatIsNegligible?: boolean | undefined;
-      showSimplifiedTable?: boolean | undefined;
-    },
-    opt: { language?: string },
-    s: string
-  ) {
+  test('simplifiedDeclaration.empty', async () => {
     const statement = simplifiedDeclarationStatement(
-      { ...falsy, ...o },
-      { language: 'en', ...opt }
+      { ...falsy },
+      { language: 'en' }
     );
-    console.log('simplifiedDeclarationStatement:', statement);
-    return expect(statement).toMatchInlineSnapshot(s);
-  }
-
-  test('simplifiedDeclaration.empty', async () => {
-    _expect({}, { language: 'en' }, '""');
+    expect(statement).toMatchInlineSnapshot('""');
   });
 
   test('simplifiedDeclaration.fat', async () => {
-    _expect(
+    const statement = simplifiedDeclarationStatement(
       {
+        ...falsy,
         fatIsNegligible: true,
       },
-      { language: 'en' },
+      { language: 'en' }
+    );
+    expect(statement).toMatchInlineSnapshot(
       '"<span>Contains negligible amounts of fat and saturates.</span>"'
     );
   });
   test('simplifiedDeclaration.fat.protein', async () => {
-    _expect(
+    const statement = simplifiedDeclarationStatement(
       {
+        ...falsy,
         fatIsNegligible: true,
         proteinIsNegligible: true,
       },
-      { language: 'en' },
+      { language: 'en' }
+    );
+    expect(statement).toMatchInlineSnapshot(
       '"<span>Contains negligible amounts of fat, saturates and protein.</span>"'
     );
   });
   test('simplifiedDeclaration.fat.salt', async () => {
-    _expect(
+    const statement = simplifiedDeclarationStatement(
       {
+        ...falsy,
         fatIsNegligible: true,
         saltIsNegligible: true,
       },
-      { language: 'en' },
+      { language: 'en' }
+    );
+    expect(statement).toMatchInlineSnapshot(
       '"<span>Contains negligible amounts of fat, saturates and salt.</span>"'
     );
   });
-  test('simplifiedDeclaration.fat.protein.carbohydrates', async () => {
-    _expect(
+  test('simplifiedDeclaration.fat.protein.carbohydrates.sugars', async () => {
+    const enStatement = simplifiedDeclarationStatement(
       {
+        ...falsy,
         fatIsNegligible: true,
         proteinIsNegligible: true,
         carbohydratesIsNegligible: true,
+        carbohydrateSugarsIsNegligible: true,
       },
-      { language: 'en' },
+      { language: 'en' }
+    );
+    expect(enStatement).toMatchInlineSnapshot(
       '"<span>Contains negligible amounts of fat, saturates, carbohydrate, sugars and protein.</span>"'
     );
-    _expect(
+
+    const frStatement = simplifiedDeclarationStatement(
       {
+        ...falsy,
         fatIsNegligible: true,
         proteinIsNegligible: true,
         carbohydratesIsNegligible: true,
+        carbohydrateSugarsIsNegligible: true,
       },
-      { language: 'fr' },
+      { language: 'fr' }
+    );
+    expect(frStatement).toMatchInlineSnapshot(
       '"<span>Contient des quantités négligeables de matières grasses, acides gras saturés, glucides, sucres et protéines.</span>"'
     );
   });
+  test('simplifiedDeclaration.fat.protein.carbohydrates', async () => {
+    const enStatement = simplifiedDeclarationStatement(
+      {
+        ...falsy,
+        fatIsNegligible: true,
+        proteinIsNegligible: true,
+        carbohydratesIsNegligible: true,
+      },
+      { language: 'en' }
+    );
+    expect(enStatement).toMatchInlineSnapshot(
+      '"<span>Contains negligible amounts of fat, saturates, carbohydrate and protein.</span>"'
+    );
+
+    const frStatement = simplifiedDeclarationStatement(
+      {
+        ...falsy,
+        fatIsNegligible: true,
+        proteinIsNegligible: true,
+        carbohydratesIsNegligible: true,
+      },
+      { language: 'fr' }
+    );
+    expect(frStatement).toMatchInlineSnapshot(
+      '"<span>Contient des quantités négligeables de matières grasses, acides gras saturés, glucides et protéines.</span>"'
+    );
+  });
+  test('simplifiedDeclaration.fat.protein.sugars', async () => {
+    const statement = simplifiedDeclarationStatement(
+      {
+        ...falsy,
+        fatIsNegligible: true,
+        proteinIsNegligible: true,
+        carbohydrateSugarsIsNegligible: true,
+      },
+      { language: 'en' }
+    );
+    expect(statement).toMatchInlineSnapshot(
+      '"<span>Contains negligible amounts of fat, saturates, sugars and protein.</span>"'
+    );
+  });
+  test('simplifiedDeclaration.sugars', async () => {
+    const statement = simplifiedDeclarationStatement(
+      {
+        ...falsy,
+        carbohydrateSugarsIsNegligible: true,
+      },
+      { language: 'en' }
+    );
+    expect(statement).toMatchInlineSnapshot(
+      '"<span>Contains negligible amounts of sugars.</span>"'
+    );
+  });
 
   test('simplifiedDeclaration.protein', async () => {
-    _expect(
+    const statement1 = simplifiedDeclarationStatement(
       {
+        ...falsy,
         proteinIsNegligible: true,
       },
-      { language: 'sk' },
+      { language: 'sk' }
+    );
+    expect(statement1).toMatchInlineSnapshot(
       '"<span>Obsahuje zanedbateľné množstvá bielkovín.</span>"'
     );
-    _expect(
+
+    const statement2 = simplifiedDeclarationStatement(
       {
+        ...falsy,
         carbohydratesIsNegligible: true,
+        carbohydrateSugarsIsNegligible: true,
         proteinIsNegligible: true,
         saltIsNegligible: true,
       },
-      { language: 'sk' },
+      { language: 'sk' }
+    );
+    expect(statement2).toMatchInlineSnapshot(
       '"<span>Obsahuje zanedbateľné množstvá sacharidov, cukrov, bielkovín a soli.</span>"'
     );
-    _expect(
+    const statement3 = simplifiedDeclarationStatement(
       {
+        ...falsy,
         carbohydratesIsNegligible: true,
+        carbohydrateSugarsIsNegligible: true,
       },
-      { language: 'en' },
+      { language: 'en' }
+    );
+    expect(statement3).toMatchInlineSnapshot(
       '"<span>Contains negligible amounts of carbohydrate and sugars.</span>"'
     );
   });

package/src/validValues/otherTranslations/simplifiedDeclarationStatement.ts

@@ -6,6 +6,7 @@ export function simplifiedDeclarationStatement(
     proteinIsNegligible,
     saltIsNegligible,
     carbohydratesIsNegligible,
+    carbohydrateSugarsIsNegligible,
     showSimplifiedTable,
   }: {
     fatIsNegligible?: boolean;
@@ -13,6 +14,7 @@ export function simplifiedDeclarationStatement(
     saltIsNegligible?: boolean;
     saturatedFatIsNegligible?: boolean;
     carbohydratesIsNegligible?: boolean;
+    carbohydrateSugarsIsNegligible?: boolean;
     showSimplifiedTable?: boolean;
   },
   { language }: { language: string }
@@ -24,6 +26,7 @@ export function simplifiedDeclarationStatement(
     language,
     fatIsNegligible,
     carbohydratesIsNegligible,
+    carbohydrateSugarsIsNegligible,
     proteinIsNegligible,
     saltIsNegligible,
   });
@@ -49,12 +52,14 @@ function getSimplifiedDeclarationItemsText({
   proteinIsNegligible,
   saltIsNegligible,
   carbohydratesIsNegligible,
+  carbohydrateSugarsIsNegligible,
 }: {
   language: string;
   fatIsNegligible?: boolean;
   proteinIsNegligible?: boolean;
   saltIsNegligible?: boolean;
   carbohydratesIsNegligible?: boolean;
+  carbohydrateSugarsIsNegligible?: boolean;
   showSimplifiedTable?: boolean;
 }): string {
   // fat and saturates
@@ -69,7 +74,7 @@ function getSimplifiedDeclarationItemsText({
   const carbohidratesTranslation = carbohydratesIsNegligible
     ? translate('simplifiedDeclaration.carbohydrates', language)
     : null;
-  const carbohidrateSugarsTranslation = carbohydratesIsNegligible
+  const carbohidrateSugarsTranslation = carbohydrateSugarsIsNegligible
     ? translate('simplifiedDeclaration.carbohydrateSugars', language)
     : null;