govuk_publishing_components 32.1.0 → 33.1.0

data/node_modules/govuk-frontend/govuk/i18n.js

@@ -0,0 +1,390 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define('GOVUKFrontend', ['exports'], factory) :
+	(factory((global.GOVUKFrontend = {})));
+}(this, (function (exports) { 'use strict';
+
+/**
+ * Internal support for selecting messages to render, with placeholder
+ * interpolation and locale-aware number formatting and pluralisation
+ *
+ * @class
+ * @private
+ * @param {TranslationsFlattened} translations - Key-value pairs of the translation strings to use.
+ * @param {object} [config] - Configuration options for the function.
+ * @param {string} config.locale - An overriding locale for the PluralRules functionality.
+ */
+function I18n (translations, config) {
+  // Make list of translations available throughout function
+  this.translations = translations || {};
+
+  // The locale to use for PluralRules and NumberFormat
+  this.locale = (config && config.locale) || document.documentElement.lang || 'en';
+}
+
+/**
+ * The most used function - takes the key for a given piece of UI text and
+ * returns the appropriate string.
+ *
+ * @param {string} lookupKey - The lookup key of the string to use.
+ * @param {object} options - Any options passed with the translation string, e.g: for string interpolation.
+ * @returns {string} The appropriate translation string.
+ */
+I18n.prototype.t = function (lookupKey, options) {
+  if (!lookupKey) {
+    // Print a console error if no lookup key has been provided
+    throw new Error('i18n: lookup key missing')
+  }
+
+  // If the `count` option is set, determine which plural suffix is needed and
+  // change the lookupKey to match. We check to see if it's undefined instead of
+  // falsy, as this could legitimately be 0.
+  if (options && typeof options.count !== 'undefined') {
+    // Get the plural suffix
+    lookupKey = lookupKey + '.' + this.getPluralSuffix(lookupKey, options.count);
+  }
+
+  if (lookupKey in this.translations) {
+    // Fetch the translation string for that lookup key
+    var translationString = this.translations[lookupKey];
+
+    // Check for ${} placeholders in the translation string
+    if (translationString.match(/%{(.\S+)}/)) {
+      if (!options) {
+        throw new Error('i18n: cannot replace placeholders in string if no option data provided')
+      }
+
+      return this.replacePlaceholders(translationString, options)
+    } else {
+      return translationString
+    }
+  } else {
+    // If the key wasn't found in our translations object,
+    // return the lookup key itself as the fallback
+    return lookupKey
+  }
+};
+
+/**
+ * Takes a translation string with placeholders, and replaces the placeholders
+ * with the provided data
+ *
+ * @param {string} translationString - The translation string
+ * @param {object} options - Any options passed with the translation string, e.g: for string interpolation.
+ * @returns {string} The translation string to output, with ${} placeholders replaced
+ */
+I18n.prototype.replacePlaceholders = function (translationString, options) {
+  var formatter;
+
+  if (this.hasIntlNumberFormatSupport()) {
+    formatter = new Intl.NumberFormat(this.locale);
+  }
+
+  return translationString.replace(/%{(.\S+)}/g, function (placeholderWithBraces, placeholderKey) {
+    if (Object.prototype.hasOwnProperty.call(options, placeholderKey)) {
+      var placeholderValue = options[placeholderKey];
+
+      // If a user has passed `false` as the value for the placeholder
+      // treat it as though the value should not be displayed
+      if (placeholderValue === false) {
+        return ''
+      }
+
+      // If the placeholder's value is a number, localise the number formatting
+      if (typeof placeholderValue === 'number' && formatter) {
+        return formatter.format(placeholderValue)
+      }
+
+      return placeholderValue
+    } else {
+      throw new Error('i18n: no data found to replace ' + placeholderWithBraces + ' placeholder in string')
+    }
+  })
+};
+
+/**
+ * Check to see if the browser supports Intl and Intl.PluralRules.
+ *
+ * It requires all conditions to be met in order to be supported:
+ * - The browser supports the Intl class (true in IE11)
+ * - The implementation of Intl supports PluralRules (NOT true in IE11)
+ * - The browser/OS has plural rules for the current locale (browser dependent)
+ *
+ * @returns {boolean} Returns true if all conditions are met. Returns false otherwise.
+ */
+I18n.prototype.hasIntlPluralRulesSupport = function () {
+  return Boolean(window.Intl && ('PluralRules' in window.Intl && Intl.PluralRules.supportedLocalesOf(this.locale).length))
+};
+
+/**
+ * Check to see if the browser supports Intl and Intl.NumberFormat.
+ *
+ * It requires all conditions to be met in order to be supported:
+ * - The browser supports the Intl class (true in IE11)
+ * - The implementation of Intl supports NumberFormat (also true in IE11)
+ * - The browser/OS has number formatting rules for the current locale (browser dependent)
+ *
+ * @returns {boolean} Returns true if all conditions are met. Returns false otherwise.
+ */
+I18n.prototype.hasIntlNumberFormatSupport = function () {
+  return Boolean(window.Intl && ('NumberFormat' in window.Intl && Intl.NumberFormat.supportedLocalesOf(this.locale).length))
+};
+
+/**
+ * Get the appropriate suffix for the plural form.
+ *
+ * Uses Intl.PluralRules (or our own fallback implementation) to get the
+ * 'preferred' form to use for the given count.
+ *
+ * Checks that a translation has been provided for that plural form – if it
+ * hasn't, it'll fall back to the 'other' plural form (unless that doesn't exist
+ * either, in which case an error will be thrown)
+ *
+ * @param {string} lookupKey - The lookup key of the string to use.
+ * @param {number} count - Number used to determine which pluralisation to use.
+ * @returns {PluralRule} The suffix associated with the correct pluralisation for this locale.
+ */
+I18n.prototype.getPluralSuffix = function (lookupKey, count) {
+  // Validate that the number is actually a number.
+  //
+  // Number(count) will turn anything that can't be converted to a Number type
+  // into 'NaN'. isFinite filters out NaN, as it isn't a finite number.
+  count = Number(count);
+  if (!isFinite(count)) { return 'other' }
+
+  var preferredForm;
+
+  // Check to verify that all the requirements for Intl.PluralRules are met.
+  // If so, we can use that instead of our custom implementation. Otherwise,
+  // use the hardcoded fallback.
+  if (this.hasIntlPluralRulesSupport()) {
+    preferredForm = new Intl.PluralRules(this.locale).select(count);
+  } else {
+    preferredForm = this.selectPluralFormUsingFallbackRules(count);
+  }
+
+  // Use the correct plural form if provided
+  if (lookupKey + '.' + preferredForm in this.translations) {
+    return preferredForm
+  // Fall back to `other` if the plural form is missing, but log a warning
+  // to the console
+  } else if (lookupKey + '.other' in this.translations) {
+    if (console && 'warn' in console) {
+      console.warn('i18n: Missing plural form ".' + preferredForm + '" for "' +
+        this.locale + '" locale. Falling back to ".other".');
+    }
+
+    return 'other'
+  // If the required `other` plural form is missing, all we can do is error
+  } else {
+    throw new Error(
+      'i18n: Plural form ".other" is required for "' + this.locale + '" locale'
+    )
+  }
+};
+
+/**
+ * Get the plural form using our fallback implementation
+ *
+ * This is split out into a separate function to make it easier to test the
+ * fallback behaviour in an environment where Intl.PluralRules exists.
+ *
+ * @param {number} count - Number used to determine which pluralisation to use.
+ * @returns {PluralRule} The pluralisation form for count in this locale.
+ */
+I18n.prototype.selectPluralFormUsingFallbackRules = function (count) {
+  // Currently our custom code can only handle positive integers, so let's
+  // make sure our number is one of those.
+  count = Math.abs(Math.floor(count));
+
+  var ruleset = this.getPluralRulesForLocale();
+
+  if (ruleset) {
+    return I18n.pluralRules[ruleset](count)
+  }
+
+  return 'other'
+};
+
+/**
+ * Work out which pluralisation rules to use for the current locale
+ *
+ * The locale may include a regional indicator (such as en-GB), but we don't
+ * usually care about this part, as pluralisation rules are usually the same
+ * regardless of region. There are exceptions, however, (e.g. Portuguese) so
+ * this searches by both the full and shortened locale codes, just to be sure.
+ *
+ * @returns {PluralRuleName | undefined} The name of the pluralisation rule to use (a key for one
+ *   of the functions in this.pluralRules)
+ */
+I18n.prototype.getPluralRulesForLocale = function () {
+  var locale = this.locale;
+  var localeShort = locale.split('-')[0];
+
+  // Look through the plural rules map to find which `pluralRule` is
+  // appropriate for our current `locale`.
+  for (var pluralRule in I18n.pluralRulesMap) {
+    if (Object.prototype.hasOwnProperty.call(I18n.pluralRulesMap, pluralRule)) {
+      var languages = I18n.pluralRulesMap[pluralRule];
+      for (var i = 0; i < languages.length; i++) {
+        if (languages[i] === locale || languages[i] === localeShort) {
+          return pluralRule
+        }
+      }
+    }
+  }
+};
+
+/**
+ * Map of plural rules to languages where those rules apply.
+ *
+ * Note: These groups are named for the most dominant or recognisable language
+ * that uses each system. The groupings do not imply that the languages are
+ * related to one another. Many languages have evolved the same systems
+ * independently of one another.
+ *
+ * Code to support more languages can be found in the i18n spike:
+ * {@link https://github.com/alphagov/govuk-frontend/blob/spike-i18n-support/src/govuk/i18n.mjs}
+ *
+ * Languages currently supported:
+ *
+ * Arabic: Arabic (ar)
+ * Chinese: Burmese (my), Chinese (zh), Indonesian (id), Japanese (ja),
+ *   Javanese (jv), Korean (ko), Malay (ms), Thai (th), Vietnamese (vi)
+ * French: Armenian (hy), Bangla (bn), French (fr), Gujarati (gu), Hindi (hi),
+ *   Persian Farsi (fa), Punjabi (pa), Zulu (zu)
+ * German: Afrikaans (af), Albanian (sq), Azerbaijani (az), Basque (eu),
+ *   Bulgarian (bg), Catalan (ca), Danish (da), Dutch (nl), English (en),
+ *   Estonian (et), Finnish (fi), Georgian (ka), German (de), Greek (el),
+ *   Hungarian (hu), Luxembourgish (lb), Norwegian (no), Somali (so),
+ *   Swahili (sw), Swedish (sv), Tamil (ta), Telugu (te), Turkish (tr),
+ *   Urdu (ur)
+ * Irish: Irish Gaelic (ga)
+ * Russian: Russian (ru), Ukrainian (uk)
+ * Scottish: Scottish Gaelic (gd)
+ * Spanish: European Portuguese (pt-PT), Italian (it), Spanish (es)
+ * Welsh: Welsh (cy)
+ *
+ * @type {Object<PluralRuleName, string[]>}
+ */
+I18n.pluralRulesMap = {
+  arabic: ['ar'],
+  chinese: ['my', 'zh', 'id', 'ja', 'jv', 'ko', 'ms', 'th', 'vi'],
+  french: ['hy', 'bn', 'fr', 'gu', 'hi', 'fa', 'pa', 'zu'],
+  german: [
+    'af', 'sq', 'az', 'eu', 'bg', 'ca', 'da', 'nl', 'en', 'et', 'fi', 'ka',
+    'de', 'el', 'hu', 'lb', 'no', 'so', 'sw', 'sv', 'ta', 'te', 'tr', 'ur'
+  ],
+  irish: ['ga'],
+  russian: ['ru', 'uk'],
+  scottish: ['gd'],
+  spanish: ['pt-PT', 'it', 'es'],
+  welsh: ['cy']
+};
+
+/**
+ * Different pluralisation rule sets
+ *
+ * Returns the appropriate suffix for the plural form associated with `n`.
+ * Possible suffixes: 'zero', 'one', 'two', 'few', 'many', 'other' (the actual
+ * meaning of each differs per locale). 'other' should always exist, even in
+ * languages without plurals, such as Chinese.
+ * {@link https://cldr.unicode.org/index/cldr-spec/plural-rules}
+ *
+ * The count must be a positive integer. Negative numbers and decimals aren't accounted for
+ *
+ * @type {Object<string, function(number): PluralRule>}
+ */
+I18n.pluralRules = {
+  arabic: function (n) {
+    if (n === 0) { return 'zero' }
+    if (n === 1) { return 'one' }
+    if (n === 2) { return 'two' }
+    if (n % 100 >= 3 && n % 100 <= 10) { return 'few' }
+    if (n % 100 >= 11 && n % 100 <= 99) { return 'many' }
+    return 'other'
+  },
+  chinese: function () {
+    return 'other'
+  },
+  french: function (n) {
+    return n === 0 || n === 1 ? 'one' : 'other'
+  },
+  german: function (n) {
+    return n === 1 ? 'one' : 'other'
+  },
+  irish: function (n) {
+    if (n === 1) { return 'one' }
+    if (n === 2) { return 'two' }
+    if (n >= 3 && n <= 6) { return 'few' }
+    if (n >= 7 && n <= 10) { return 'many' }
+    return 'other'
+  },
+  russian: function (n) {
+    var lastTwo = n % 100;
+    var last = lastTwo % 10;
+    if (last === 1 && lastTwo !== 11) { return 'one' }
+    if (last >= 2 && last <= 4 && !(lastTwo >= 12 && lastTwo <= 14)) { return 'few' }
+    if (last === 0 || (last >= 5 && last <= 9) || (lastTwo >= 11 && lastTwo <= 14)) { return 'many' }
+    // Note: The 'other' suffix is only used by decimal numbers in Russian.
+    // We don't anticipate it being used, but it's here for consistency.
+    return 'other'
+  },
+  scottish: function (n) {
+    if (n === 1 || n === 11) { return 'one' }
+    if (n === 2 || n === 12) { return 'two' }
+    if ((n >= 3 && n <= 10) || (n >= 13 && n <= 19)) { return 'few' }
+    return 'other'
+  },
+  spanish: function (n) {
+    if (n === 1) { return 'one' }
+    if (n % 1000000 === 0 && n !== 0) { return 'many' }
+    return 'other'
+  },
+  welsh: function (n) {
+    if (n === 0) { return 'zero' }
+    if (n === 1) { return 'one' }
+    if (n === 2) { return 'two' }
+    if (n === 3) { return 'few' }
+    if (n === 6) { return 'many' }
+    return 'other'
+  }
+};
+
+/**
+ * Supported languages for plural rules
+ *
+ * @typedef {'arabic' | 'chinese' | 'french' | 'german' | 'irish' | 'russian' | 'scottish' | 'spanish' | 'welsh'} PluralRuleName
+ */
+
+/**
+ * Plural rule category mnemonic tags
+ *
+ * @typedef {'zero' | 'one' | 'two' | 'few' | 'many' | 'other'} PluralRule
+ */
+
+/**
+ * Translated message by plural rule they correspond to.
+ *
+ * Allows to group pluralised messages under a single key when passing
+ * translations to a component's constructor
+ *
+ * @typedef {object} TranslationPluralForms
+ * @property {string} [other] - General plural form
+ * @property {string} [zero] - Plural form used with 0
+ * @property {string} [one] - Plural form used with 1
+ * @property {string} [two] - Plural form used with 2
+ * @property {string} [few] - Plural form used for a few
+ * @property {string} [many] - Plural form used for many
+ */
+
+/**
+ * Translated messages (flattened)
+ *
+ * @private
+ * @typedef {Object<string, string> | {}} TranslationsFlattened
+ */
+
+exports.I18n = I18n;
+
+})));

data/node_modules/govuk-frontend/govuk/macros/i18n.njk

@@ -0,0 +1,15 @@
+{#
+ # Renders the data attributes for the different plural forms
+ # of the given translation key.
+ #
+ # Helps reduce the boilerplate in component templates as they're quite verbose
+ #
+ # @private
+ # @param {string} translationKey - The kebab-cased name of the translation key
+ # @param {object} pluralForms
+ #   An object associating translation messages to the plural form they correspond to
+ #   http://unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules
+ #}
+{% macro govukPluralisedI18nAttributes(translationKey, pluralForms) %}
+  {% for pluralType, message in pluralForms %} data-i18n.{{translationKey}}.{{pluralType}}="{{message | escape}}"{% endfor %}
+{% endmacro %}

data/node_modules/govuk-frontend/govuk/settings/_all.scss

@@ -3,6 +3,7 @@
 
 @import "assets";
 
+@import "warnings";
 @import "compatibility";
 @import "global-styles";
 @import "ie8";

data/node_modules/govuk-frontend/govuk/settings/_colours-palette.scss

@@ -15,6 +15,8 @@
 ///
 /// @type Boolean
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $govuk-use-legacy-palette: if(
   (
@@ -26,6 +28,16 @@ $govuk-use-legacy-palette: if(
   false
 ) !default;
 
+// Only show the deprecation warning if user is setting $govuk-use-legacy-palette
+// manually instead of automatically via compatibility variables
+@if $govuk-use-legacy-palette == true and
+  $govuk-compatibility-govukfrontendtoolkit == false and
+  $govuk-compatibility-govuktemplate == false and
+  $govuk-compatibility-govukelements == false {
+  @include _warning(legacy-palette, "$govuk-use-legacy-palette is deprecated. " +
+  "Only the modern colour palette will be supported from v5.0.");
+}
+
 /// Modern colour palette
 ///
 /// This exists only because you cannot easily set a !default variable

data/node_modules/govuk-frontend/govuk/settings/_compatibility.scss

@@ -23,9 +23,17 @@
 ///
 /// @type Boolean
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $govuk-compatibility-govukfrontendtoolkit: false !default;
 
+@if $govuk-compatibility-govukfrontendtoolkit == true {
+  @include _warning("compatibility-mode", "$govuk-compatibility-govukfrontendtoolkit " +
+  "is deprecated. From version 5.0, GOV.UK Frontend will remove compatibility " +
+  "with the legacy library govuk_frontend_toolkit.");
+}
+
 /// Compatibility Mode: alphagov/govuk_template
 ///
 /// Enabling this will:
@@ -41,9 +49,17 @@ $govuk-compatibility-govukfrontendtoolkit: false !default;
 ///
 /// @type Boolean
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $govuk-compatibility-govuktemplate: false !default;
 
+@if $govuk-compatibility-govuktemplate == true {
+  @include _warning("compatibility-mode", "$govuk-compatibility-govuktemplate " +
+  "is deprecated. From version 5.0, GOV.UK Frontend will remove " +
+  "compatibility with the legacy library govuk_template.");
+}
+
 /// Compatibility Mode: alphagov/govuk_elements
 ///
 /// Enabling this will:
@@ -56,9 +72,17 @@ $govuk-compatibility-govuktemplate: false !default;
 ///
 /// @type Boolean
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $govuk-compatibility-govukelements: false !default;
 
+@if $govuk-compatibility-govukelements == true {
+  @include _warning("compatibility-mode", "$govuk-compatibility-govukelements " +
+  "is deprecated. From version 5.0, GOV.UK Frontend will remove compatibility " +
+  "with the legacy library govuk_elements.");
+}
+
 /// Compatibility Product Map
 ///
 /// Maps product names to their settings that we can use to lookup states from
@@ -66,6 +90,8 @@ $govuk-compatibility-govukelements: false !default;
 ///
 /// @type Map
 /// @access private
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $_govuk-compatibility: (
   govuk_frontend_toolkit: $govuk-compatibility-govukfrontendtoolkit,

data/node_modules/govuk-frontend/govuk/settings/_typography-font.scss

@@ -13,6 +13,8 @@
 ///
 /// @type Boolean
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $govuk-use-legacy-font: if(
   (
@@ -24,6 +26,17 @@ $govuk-use-legacy-font: if(
   false
 ) !default;
 
+// Only show the deprecation warning if user is setting $govuk-use-legacy-font
+// manually instead of automatically via compatibility variables
+@if $govuk-use-legacy-font == true and
+  $govuk-compatibility-govukfrontendtoolkit == false and
+  $govuk-compatibility-govuktemplate == false and
+  $govuk-compatibility-govukelements == false {
+  @include _warning(legacy-font, "$govuk-use-legacy-font is deprecated. " +
+  "From version 5.0, GOV.UK Frontend will only support the included version " +
+  "of GDS Transport.");
+}
+
 // =========================================================
 // Font families
 // =========================================================
@@ -43,6 +56,8 @@ $govuk-font-family: if(
 ///
 /// @type List
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $govuk-font-family-tabular: if(
   $govuk-use-legacy-font,
@@ -50,6 +65,14 @@ $govuk-font-family-tabular: if(
   false
 ) !default;
 
+// Only show the deprecation warning if user is setting $govuk-font-family-tabular
+// manually instead of automatically via $govuk-use-legacy-font
+@if $govuk-font-family-tabular != false and $govuk-use-legacy-font == false {
+  @include _warning(tabular-font-face, "$govuk-font-family-tabular is deprecated. " +
+  "From version 5.0, GOV.UK Frontend will not support using a separate " +
+  "font-face for tabular numbers.");
+}
+
 /// Font families to use for print media
 ///
 /// We recommend that you use system fonts when printing. This will avoid issues

data/node_modules/govuk-frontend/govuk/settings/_typography-responsive.scss

@@ -13,6 +13,8 @@
 ///
 /// @type Boolean
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 $govuk-typography-use-rem: if(
   (
@@ -24,6 +26,16 @@ $govuk-typography-use-rem: if(
   true
 ) !default;
 
+// Only show the deprecation warning if user is setting $govuk-typography-use-rem
+// manually instead of automatically via compatibility variables
+@if $govuk-typography-use-rem == false and
+  $govuk-compatibility-govukfrontendtoolkit == false and
+  $govuk-compatibility-govuktemplate == false and
+  $govuk-compatibility-govukelements == false {
+  @include _warning(allow-not-using-rem, "$govuk-typography-use-rem is deprecated. " +
+  "From version 5.0, GOV.UK Frontend will not support disabling rem font sizes.");
+}
+
 /// Root font size
 ///
 /// This is used to calculate rem sizes for the typography, and should match the

data/node_modules/govuk-frontend/govuk/settings/_warnings.scss

@@ -0,0 +1,53 @@
+////
+/// @group settings/warnings
+////
+
+/// Suppressed warnings map
+///
+/// This map is used to determine which deprecation warnings to **not** show
+/// to users when compiling sass. This is in place for codebases that do not
+/// have the necessary capacity to upgrade and remove the deprecation,
+/// particularly if the deprecation is significant. For example, removal of
+/// compatibility with legacy libraries such as govuk_elements.
+///
+/// You can add to this map and define which warnings to suppress by appending to
+/// it using the warning key, found in the warning message. For example:
+///
+/// @example scss:
+///   // warning message:
+///   //  $foobar is no longer supported. To silence this warning, update
+///   //  $govuk-suppressed-warnings with key: "foobar"
+///   $govuk-suppressed-warnings: (
+///     foobar
+///   );
+///
+/// @type List
+/// @access public
+
+$govuk-suppressed-warnings: () !default;
+
+/// Warnings
+///
+/// Acts as a wrapper for the built in `@warn` sass function
+///
+/// We use this instead of using `@warn` for 3 reasons:
+///
+/// - To check if a warning is being suppressed through `$govuk-suppressed-warnings`,
+/// in which case we don't call `@warn` and printing the warning to the user
+/// - To format the passed warning `$message` with the warning key at the end
+/// - To prevent duplicate warnings by adding the passed `$key` to
+/// `$govuk-suppressed-warnings` after `@warn` is called to ensure it only runs
+/// once per sass compilation
+///
+/// @param {String} $key - The key to be checked against `$govuk-suppressed-warnings`
+/// and then passed to it to prevent multiple of the same warning.
+/// @param {String} $message - The message to use when calling `@warn`
+/// @access private
+
+@mixin _warning($key, $message) {
+  @if not index($govuk-suppressed-warnings, $key) {
+    @warn $message + " To silence this warning, update $govuk-suppressed-warnings " +
+      "with key: \"#{$key}\"";
+    $govuk-suppressed-warnings: append($govuk-suppressed-warnings, $key) !global;
+  }
+}

data/node_modules/govuk-frontend/govuk/tools/_compatibility.scss

@@ -2,6 +2,20 @@
 /// @group tools/compatibility-mode
 ////
 
+/// Temporary private version of govuk-compatibility to avoid deprecation warnings
+///
+/// @access private
+
+@mixin _govuk-compatibility($product) {
+  @if map-has-key($_govuk-compatibility, $product) {
+    @if map-get($_govuk-compatibility, $product) == true {
+      @content;
+    }
+  } @else {
+    @error "Non existent product '#{$product}'";
+  }
+}
+
 /// Conditional Compatibility Mixin
 ///
 /// Selectively output a block (available to the mixin as @content) if a given
@@ -24,13 +38,13 @@
 ///   this product
 /// @throw Errors if product name is not recognised
 /// @access public
+/// @deprecated Will be removed in v5.0 with the rest of the compatibility mode
+/// suite of tools and settings
 
 @mixin govuk-compatibility($product) {
-  @if map-has-key($_govuk-compatibility, $product) {
-    @if map-get($_govuk-compatibility, $product) == true {
-      @content;
-    }
-  } @else {
-    @error "Non existent product '#{$product}'";
+  @include _warning(compatibility-helper, "govuk-compatibility is deprecated. " +
+  "From version 5.0, GOV.UK Frontend will not support compatibility mode.");
+  @include _govuk-compatibility($product) {
+    @content;
   }
 }