@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/base/message-registry.js

@@ -30,8 +30,8 @@
 
 'use strict';
 
-const { CompilerAssertion } = require("./error");
-const { createDict } = require("../utils/objectUtils");
+const { CompilerAssertion } = require('./error');
+const { createDict } = require('../utils/objectUtils');
 
 /**
  * Central register of messages and their configuration.
@@ -116,6 +116,7 @@ const centralMessages = {
   'type-ambiguous-target': { severity: 'Warning' },
 
   'ref-autoexposed': { severity: 'Error', configurableFor: 'deprecated' },
+  // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
   'ref-undefined-art':    { severity: 'Error' },
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
@@ -137,20 +138,22 @@ const centralMessages = {
 
   'expr-unexpected-operator': { severity: 'Error', configurableFor: true },
 
+  // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
+  // Also used by other projects that rely on double-quotes for delimited identifiers.
+  'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
   // 'syntax-duplicate-annotate' came late with v3 - make it configurable as
   // fallback, but then parse.cdl is not supposed to work correctly (it can
   // then either issue an error or produce a CSN missing some annotations):
-  'syntax-duplicate-annotate': { severity: 'Error', configurableFor: true },
-  'syntax-unexpected-property': { severity: 'Error' },
-  'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
-  'syntax-fragile-alias': { severity: 'Error', configurableFor: true },
-  'syntax-fragile-ident': { severity: 'Error', configurableFor: true },
+  'syntax-duplicate-annotate': { severity: 'Error', configurableFor: 'v3' },
+  'syntax-invalid-name': { severity: 'Error', configurableFor: 'v3' },
+  'syntax-missing-as': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
-
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'v3' },
-  'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
 
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
+  'type-unsupported-precision-change': { severity: 'Error'},
 
   'def-missing-element': { severity: 'Error' },
 
@@ -176,6 +179,12 @@ const centralMessages = {
   'odata-spec-violation-key-null': { severity: 'Error', configurableFor: true }, // more than 30 chars
   'odata-spec-violation-key-type': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
+  'odata-anno-preproc': { severity: 'Warning', configurableFor: true },
+  'odata-anno-dict': { severity: 'Warning', configurableFor: true },
+  'odata-anno-dict-enum': { severity: 'Error' },
+  'odata-anno-value': { severity: 'Warning', configurableFor: true },
+  'odata-anno-type': { severity: 'Warning', configurableFor: true },
+  'odata-anno-def': { severity: 'Info', configurableFor: true },
 };
 
 // Old/Deprecated message IDs that we only still use for backwards-compatibility.
@@ -190,9 +199,9 @@ const oldMessageIds = createDict({
 for (const oldName in oldMessageIds) {
   const newName = oldMessageIds[oldName];
   if (centralMessages[oldName])
-    throw new CompilerAssertion(`Mapping from ${oldName} not possible: ID is still used in message registry.`);
+    throw new CompilerAssertion(`Mapping from ${ oldName } not possible: ID is still used in message registry.`);
   if (!centralMessages[newName])
-    throw new CompilerAssertion(`Mapping from ${oldName} to new message ID ${newName} does not exist!`);
+    throw new CompilerAssertion(`Mapping from ${ oldName } to new message ID ${ newName } does not exist!`);
 
   if (!centralMessages[newName].oldNames)
     centralMessages[newName].oldNames = [ oldName ];
@@ -231,30 +240,44 @@ const centralMessageTexts = {
     'flatten-fkey-gen': 'Duplicate definition of foreign key element $(NAME) for association $(ART)',
     'flatten-fkey-exists': 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element',
   },
-  
-  // Syntax messages, both CDL and CSN parser: ----------------------------------
-  'syntax-dollar-ident': {      // Warning, TODO: make it name-invalid-alias
-    std: 'An artifact starting with $(NAME) might shadow a special variable - replace by another name',
+  'name-invalid-dollar-alias': {      // Warning
+    std: 'An alias name starting with $(NAME) might shadow a special variable - replace by another name',
     $tableAlias: 'A table alias name starting with $(NAME) might shadow a special variable - replace by another name',
     $tableImplicit: 'The resulting table alias starts with $(NAME) and might shadow a special variable - specify another name with $(KEYWORD)',
     mixin: 'A mixin name starting with $(NAME) might shadow a special variable - replace by another name',
   },
-  // 'syntax-duplicate-excluding' (TODO: also CDL)
+
+  // Syntax messages, both CDL and CSN parser: ----------------------------------
+  'syntax-deprecated-abstract': {
+    std: 'Abstract entity definitions are deprecated; use aspect definitions instead',
+    'strange-kind': 'The property $(PROP) is deprecated; expecting it only with kind $(KIND) to define an aspect',
+  },
+  'syntax-duplicate-excluding': {
+    std: 'Duplicate $(NAME) in the $(KEYWORD) clause',
+    csn: 'Duplicate $(NAME) in property $(PROP)',
+  },
+  'syntax-expecting-unsigned-int': { // TODO: test all in SyntaxOnly/
+    std: 'A safe non-negative integer is expected here',
+    normal: 'A non-negative integer number is expected here',
+    unsafe: 'The provided integer is too large',
+    csn: 'Expecting a non-negative integer for property $(PROP)'
+  },
   'syntax-ignoring-anno': {
-    std: 'Annotations can\'t be used at prefix references',
-    doc: 'Doc comments can\'t be used at prefix references',
+    std: 'Annotations can\'t be used in a column with $(CODE)',
+    doc: 'Doc comments can\'t be used in a column with $(CODE)',
   },
   'syntax-invalid-name': {
-    std: 'Identifier for name must not be empty', // TODO: use
+    std: 'Identifier must consist of at least one character',
     csn: 'Property name in dictionary $(PARENTPROP) must not be empty',
+    as: 'String in property $(PROP) must not be empty', // TODO: use
   },
-  'syntax-invalid-literal': {   // TODO: write texts less CDL specific
-    'std': 'Invalid literal',
+  'syntax-invalid-literal': {
+    'std': 'Invalid literal value',
     'uneven-hex': 'A binary literal must have an even number of characters',
-    'invalid-hex': 'A binary literal must only contain characters 0-9, a-f and A-F',
-    'time': 'Expecting time\'hh:mm:ss\' where hh, mm and the optional ss are numbers',
-    'date': 'Expecting date\'YYYY-MM-DD\' where YYYY, MM and DD are numbers',
-    'timestamp': 'Expecting timestamp\'YYYY-MM-DD hh:mm:ss.u…u\' where YYYY, MM, DD, hh, mm, ss and u are numbers (optional 1-7×u)',
+    'invalid-hex': 'A binary literal must only contain characters ‹0-9›, ‹a-f› and ‹A-F›',
+    'time': 'A time literal must look like ‹hh:mm:ss› or ‹hh:mm› where each letter represents a digit',
+    'date': 'A date literal must look like ‹YYYY-MM-DD› where each letter represents a digit',
+    'timestamp': 'A timestamp literal must look like ‹YYYY-MM-DD hh:mm:ss.u…u› or ‹YYYY-MM-DD hh:mm› where each letter represents a digit, ‹u…u› represents 1 to 7 digits',
   },
   'syntax-missing-ellipsis': 'Expecting an array item $(NEWCODE) after an item with $(CODE)',
   'syntax-unexpected-ellipsis': {
@@ -268,23 +291,52 @@ const centralMessageTexts = {
     csn: 'The property $(PROP) is not supported',
   },
 
-  // Syntax messages, CDL parser - default: Error  ------------------------------
+  // Syntax messages, CDL parser  -----------------------------------------------
+  // 'syntax-deprecated-auto-as', 'syntax-deprecated-ident'
   'syntax-duplicate-annotate': 'You can\'t refer to $(NAME) repeatedly with property $(PROP) in the same annotate statement',
+  'syntax-duplicate-argument': {
+    std: 'Duplicate value for parameter $(NAME)',
+    type: 'Duplicate value for type parameter $(NAME)',
+  },
   'syntax-duplicate-extend': {
     std: 'You can\'t define and refer to $(NAME) repeatedly in the same extend statement',
     define: 'You can\'t refer to $(NAME) in the same extend statement where it was defined',
     extend: 'You can\'t refer to $(NAME) repeatedly in the same extend statement',
   },
-  'syntax-invalid-extend': 'Can\'t extend an element with $(KIND)',
+  // 'syntax-duplicate-anno', 'syntax-duplicate-doc-comment', 'syntax-duplicate-cardinality',
+  // 'syntax-duplicate-property'
+  'syntax-unexpected-reserved-word': '$(CODE) is a reserved word - write $(DELIMITED) instead if you want to use it as name',
   'syntax-invalid-text-block': 'Missing newline in text block',
+  // 'syntax-missing-newline' (Warning), 'syntax-missing-as',
+  // 'syntax-missing-token'
+  'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
+  'syntax-unexpected-token': {
+    std: 'Mismatched $(OFFENDING), expecting $(EXPECTING)',
+    unwanted: 'Extraneous $(OFFENDING), expecting $(EXPECTING)'
+  },
+  'syntax-unexpected-vocabulary': {
+    std: 'Annotations can\'t be defined inside contexts or services', // not used
+    service: 'Annotations can\'t be defined inside services',
+    context: 'Annotations can\'t be defined inside contexts',
+  },
+  // 'syntax-unexpected-space', 'syntax-unexpected-doc-comment' (TODO is: -ignoring-, Info)
+  // 'syntax-unexpected-alias' (is 'syntax-unexpected-property' in CSN),
+  // 'syntax-unexpected-right-paren'
+  'syntax-unsupported-calc-elem': 'Calculated elements are not supported',
   'syntax-unsupported-param': {
     std: 'Parameter not supported', // unused
-    dynamic: 'Dynamic parameter $(NAME) is not supported',
-    positional: 'Positional parameter $(NAME) is not supported',
+    dynamic: 'Dynamic parameter $(CODE) is not supported',
+    positional: 'Positional parameter $(CODE) is not supported',
   },
+  // 'syntax-unsupported-method', 'syntax-unsupported-new'
 
   // Syntax messages, CSN parser - default: Error  ------------------------------
   // TODO: use one id with text variants instead of several message ids
+  'syntax-deprecated-dollar-syntax': {
+    std: 'The property $(PROP) is deprecated; its value is ignored',
+    projection: 'The property $(PROP) is deprecated; use property $(SIBLINGPROP) instead of $(OTHERPROP) for the query',
+    aspect: 'The property $(PROP) is deprecated; change the kind of the current definition to $(KIND) instead',
+  },
   'syntax-deprecated-property': {  // Warning
     std: 'Deprecated property $(PROP)', // unused
     'zero': 'Deprecated CSN v0.1.0 property $(PROP) is ignored',
@@ -299,7 +351,6 @@ const centralMessageTexts = {
 
   'syntax-expecting-object': 'Expecting object for property $(PROP)',
   'syntax-expecting-column': 'Expecting object or string \'*\' for property $(PROP)',
-  'syntax-expecting-natnum': 'Expecting non-negative number for property $(PROP)',
   'syntax-expecting-cardinality': 'Expecting non-negative number or string \'*\' for property $(PROP)',
   'syntax-expecting-reference': 'Expecting non-empty string or object for property $(PROP)',
   'syntax-expecting-term': 'Expecting non-empty string or object for property $(PROP)',
@@ -314,10 +365,10 @@ const centralMessageTexts = {
     std: 'Object in $(PROP) must have at least one valid CSN property',
     as: 'Object in $(PROP) must have at least one valid CSN property other than $(OTHERPROP)',
   },
-  // 'syntax-invalid-ref' (Warning?), 'syntax-invalid-kind', 'syntax-invalid-literal' (Warning)
   'syntax-invalid-string': {
     std: 'Invalid string value in property $(PROP)',
   },
+  // 'syntax-invalid-ref' (Warning?), 'syntax-invalid-kind', 'syntax-invalid-literal' (Warning)
   'syntax-missing-property': {  // location at sibling or '}' otherwise
     std: 'Object in $(PARENTPROP) must have the property $(PROP)',
     sibling: 'Object with property $(SIBLINGPROP) must also have a property $(PROP)',
@@ -335,6 +386,7 @@ const centralMessageTexts = {
   },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
+  // multi-line strings: --------------------------------------------------------
   'syntax-unknown-escape': 'Unknown escape sequence $(CODE)',
   'syntax-invalid-escape': {
     std: 'Invalid escape sequence $(CODE)',
@@ -342,7 +394,7 @@ const centralMessageTexts = {
     whitespace: 'Unknown escape sequence: Can\'t escape whitespace',
     codepoint: 'Undefined code-point for $(CODE)',
     'unicode-hex': 'Expecting hexadecimal numbers for unicode escape but found $(CODE)',
-    'hex-count': 'Expecting $(NUMBER) hexadecimal numbers for escape sequence but found $(CODE)',
+    'hex-count': 'Expecting $(COUNT) hexadecimal numbers for escape sequence but found $(CODE)',
     'unicode-brace': 'Missing closing brace for unicode escape sequence',
     'language-identifier': 'Escape sequences in text-block\'s language identifier are not allowed',
   },
@@ -350,26 +402,8 @@ const centralMessageTexts = {
     std: 'Missing escape. Replace $(CODE) with $(NEWCODE)',
     placeholder: 'Placeholders are not supported. Replace $(CODE) with $(NEWCODE)',
   },
-  'syntax-expecting-integer': {
-    std: 'A safe integer is expected here',
-    normal: 'An integer number is expected here',
-    unsafe: 'The provided integer is too large',
-  },
-  'syntax-duplicate-argument': { // TODO: also CDL
-    std: 'Unexpected argument $(CODE)',
-    unknown: 'Unknown argument $(CODE)', // huh?
-    duplicate: 'Duplicate argument $(CODE)',
-  },
-  'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
-  'syntax-unexpected-vocabulary': {
-    std: 'Annotations can\'t be defined inside contexts or services',
-    service: 'Annotations can\'t be defined inside services',
-    context: 'Annotations can\'t be defined inside contexts',
-  },
-  'syntax-fragile-ident': '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it',
-  'syntax-unsupported-field': 'Calculated fields are not supported, yet',
 
-  // Syntax messages for errorneous references ----------------------------------
+  // Messages for errorneous references -----------------------------------------
   // location at errorneous reference (if possible)
   'ref-unexpected-self': 'Unexpected $(ID) reference; is valid only in ON-conditions',
   'ref-undefined-def': {
@@ -385,7 +419,10 @@ const centralMessageTexts = {
     element: 'Artifact $(ART) has no element $(MEMBER)',
     aspect: 'Element $(ID) has not been found in the anonymous target aspect'
   },
-  'ref-undefined-var': 'Element or variable $(ID) has not been found',
+  'ref-undefined-var': {
+    std: 'Variable $(ID) has not been found',
+    alias: 'Variable $(ID) has not been found. Use table alias $(ALIAS) to refer an element with the same name',
+  },
   'ref-unknown-var': {
     std: 'No replacement found for special variable $(ID)'
   },
@@ -447,12 +484,34 @@ const centralMessageTexts = {
     'entity-persistence': 'SAP HANA does not allow associations in entities annotated with $(ANNO)',
     'target-persistence': 'SAP HANA does not allow associations pointing to entities annotated with $(ANNO)',
   },
+  'def-unexpected-key': {
+    std: '$(ART) can\'t have additional keys',
+    // TODO: Better message?
+    include: '$(ART) can\'t have additional keys (through include)'
+  },
+  'def-unexpected-localized': {
+    std: '$(ART) can\'t have localized elements',
+    // TODO: Better message?
+    include:  '$(ART) can\'t have localized elements (through include)',
+  },
 
   'def-missing-element': {
     std: 'Expecting entity to have at least one non-virtual element',
     view: 'Expecting view to have at least one non-virtual element'
   },
 
+  'def-invalid-texts-aspect': {
+    std: '$(ART) is not valid', // unused
+    'no-aspect': '$(ART) must be an aspect',
+    key: '$(ART) must be a key',
+    'no-key': '$(ART) must not be key',
+    'missing': '$(ART) must have an element $(NAME)',
+  },
+  'def-invalid-element-type': {
+    std: 'Element $(ELEMREF) of $(ART) must be of type $(TYPE)',
+    'texts-aspect-locale': 'Element $(ELEMREF) of $(ART) must be of type $(TYPE) or $(OTHERTYPE)',
+  },
+
   'duplicate-definition': {
     std: 'Duplicate definition of $(NAME)',
     absolute: 'Duplicate definition of artifact $(NAME)',
@@ -478,7 +537,7 @@ const centralMessageTexts = {
   'expected-target': 'An entity or an aspect is expected here',
   'extend-columns': 'Artifact $(ART) can\'t be extended with columns, only projections can',
   'extend-repeated-intralayer': 'Unstable element order due to repeated extensions in same layer',
-  'extend-unexpected-include': 'Can\'t extend $(KIND) with includes',
+  'extend-unexpected-include': 'Can\'t extend $(META) with includes',
   'ref-expecting-bare-aspect': 'An aspect without elements is expected here',
 
   'ext-duplicate-extend-type': 'Duplicate type extension for type $(TYPE)',
@@ -543,7 +602,7 @@ const centralMessageTexts = {
   // version independent messages
   'odata-spec-violation-key-array': {
     std: 'Unexpected array type for element $(NAME)',
-    scalar: 'Unexpected array type'
+    scalar: 'Unexpected array type',
   },
   'odata-spec-violation-key-null': {
     std: 'Expected key element $(NAME) to be not nullable', // structured
@@ -559,8 +618,9 @@ const centralMessageTexts = {
     std: 'Expected element to have a type',
     incompatible: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
     facet: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
+    external: 'Referenced type $(TYPE) marked as $(ANNO) can\'t be rendered as $(CODE) in service $(NAME) for OData $(VERSION)',
   },
-  'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(KIND)',
+  'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(META)',
   'odata-spec-violation-namespace': {
     std: 'Expected service name not to be one of the reserved names $(NAMES)',
     length: 'Expected service name not to exceed 511 characters',
@@ -568,7 +628,9 @@ const centralMessageTexts = {
   // Other odata/edm errors
   'odata-definition-exists': {
     std: 'Entity can\'t be created due to name collision with existing definition $(NAME)',
-    proxy: 'No proxy entity created due to name collision with existing definition $(NAME) of kind $(KIND)'
+    proxy: 'No proxy entity created due to name collision with existing definition $(NAME) of kind $(KIND)',
+    anno: 'Name of annotation definition $(ANNO) conflicts with existing service definition',
+    termredef: 'Unexpected redefinition of annotation $(ANNO)',
   },
   'odata-navigation': {
     std: 'No OData navigation property generated, target $(TARGET) is outside of service $(SERVICE)',
@@ -576,6 +638,63 @@ const centralMessageTexts = {
   },
   'odata-parameter-order': 'Unexpected mandatory after optional parameter',
   'odata-key-recursive': 'Unexpected recursive key $(NAME)',
+  // -----------------------------------------------------------------------------------
+  // All odata-anno MUST have a '$(ANNO)' parameter to indicate error location
+  // -----------------------------------------------------------------------------------
+  // Annotation Preprocessing:
+  // -----------------------------------------------------------------------------------
+  'odata-anno-preproc': {
+    'std': 'unused message text',
+    'nokey': 'Expected target $(NAME) to have a key element for $(ANNO)',
+    'multkeys': 'Expected target $(NAME) to have only one key element',
+    'vhlnokey': 'Expected value help list entity $(NAME) to have a key element for $(ANNO)',
+    'vhlmultkeys': 'Expected value help list entity $(NAME) to have only one key element for $(ANNO)',
+    'notforentity': 'Unexpected usage of $(ANNO) for an entity',
+    'viaassoc': 'Expected value to be a path for $(ANNO)',
+    'noassoc': 'Expected association $(ID) to exist for $(ANNO)',
+    'vallistignored': '$(NAME) is ignored for $(ANNO) as $(CODE) is present',
+    'notastring': 'Expected value to be a string for $(ANNO)',
+    'notexist': 'Expect entity $(ID) to exist for $(ANNO)',
+    'txtarr': 'Expect $(ANNO) shortcut to have a $(NAME) annotation'
+  },
+  // -----------------------------------------------------------------------------------
+  // GenericTranslation:
+  // -----------------------------------------------------------------------------------
+  'odata-anno-dict': {
+    // ANNO w/o sub elements, term qualifiers and context stack
+    'std': 'Vocabulary dictionary inconsistency: Type $(TYPE) not found for $(ANNO)',
+    'experimental': '$(ANNO) is experimental and can be changed or removed at any time, do not use productively!',
+    'redefinition': '$(ANNO) is an official OASIS/SAP annotation and can\'t be redefined'
+  },
+  'odata-anno-dict-enum': {
+    'std' : 'Unexpected annotation definition $(NAME) with many enum type',
+    'type': 'Unexpected annotation definition $(NAME) with many enum type $(TYPE)',
+    'value': 'Expected all enum elements of type $(TYPE) to have a value in annotation definition $(NAME)'
+  },
+  'odata-anno-value': {
+    'nested': 'Missing $(STR) annotation for $(ANNO)',
+    // -----------------------------------------------------------------------------------
+    // All mesages of odata-anno-value below here MUST have $(ANNO) filled with msgctx.anno
+    // -----------------------------------------------------------------------------------
+    'enum': 'Value $(VALUE) is not one out of $(RAWVALUES) for $(ANNO) of type $(TYPE)',
+    'std': 'Unexpected value $(VALUE) for $(ANNO) of type $(TYPE)',
+    'struct': 'Unexpected $(STR) value for $(ANNO) of type $(TYPE)',
+    'nestedcollection': 'Nested collections are not supported for $(ANNO)',
+    'enumincollection': 'Enum inside collection is not supported for $(ANNO)',
+    'multexpr': 'EDM JSON code contains more than one dynamic expression: $(RAWVALUES) for $(ANNO)',
+  },
+  'odata-anno-type': {
+    'std': '$(NAME) is not a known property for $(ANNO) of type $(TYPE)',
+    'unknown': '$(TYPE) is not a known vocabulary type for $(ANNO)',
+    'abstract': 'Unexpected abstract type $(TYPE) for $(ANNO)',
+    'derived': 'Expected specified $(TYPE) to be derived from $(NAME) for $(ANNO)',
+  },
+  'odata-anno-def': {
+    // All $(ANNO) w/o sub elements, term qualifiers and context stack
+    'std': '$(ANNO) is not a known annotation in an official OASIS/SAP namespace',
+    'deprecated': '$(ANNO) is deprecated. $(DEPR)',
+    'notapplied': '$(ANNO) is not applied (AppliesTo: $(RAWVALUES))',
+  },
 }
 
 /**
@@ -583,7 +702,7 @@ const centralMessageTexts = {
  *
  * @typedef {object} MessageConfig
  * @property {MessageSeverity} severity Default severity for the message.
- * @property {string[]|'deprecated'|true} [configurableFor]
+ * @property {string[]|'deprecated'|'v3'|true} [configurableFor]
  *        Whether the error can be reclassified to a warning or lower.
  *        If not `true` then an array is expected with specified modules in which the error is downgradable.
  *        Only has an effect if default severity is 'Error'.
@@ -597,6 +716,6 @@ const centralMessageTexts = {
  *                                 Don't set this property directly! Append to object oldMessageIds instead!
  */
 
-//console.log('FOO')
+// console.log('FOO')
 
 module.exports = { centralMessages, centralMessageTexts, oldMessageIds };