@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/language/multiLineStringParser.js

@@ -1,43 +1,15 @@
 'use strict';
 
-const whitespaceRegEx = /[\t\u{000B}\u{000C} \u{00A0}\u{FEFF}\p{Zs}]/u;
-const newLineRegEx = /\r\n?|\n|\u2028|\u2029/u;
-
-/**
- * Returns true if the given string only contains whitespace characters.
- *
- * @todo Combine with function from docCommentParser
- * @param {string} str
- * @returns {boolean}
- */
-function isWhiteSpaceOnly(str) {
-  return /^\s*$/.test(str);
-}
-
-/**
- * Check whether the given character is a white-space character as
- * defined by §11.2 of the ECMAScript 2020 specification.
- * See <https://262.ecma-international.org/11.0/#sec-white-space>.
- *
- * | Code Point          | Name                                           | Abbreviation |
- * |:--------------------|:-----------------------------------------------|--------------|
- * | U+0009              | CHARACTER TABULATION                           | `<TAB>`      |
- * | U+000B              | LINE TABULATION                                | `<VT>`       |
- * | U+000C              | FORM FEED (FF)                                 | `<FF>`       |
- * | U+0020              | SPACE                                          | `<SP>`       |
- * | U+00A0              | NO-BREAK SPACE                                 | `<NBSP>`     |
- * | U+FEFF              | ZERO WIDTH NO-BREAK SPACE                      | `<ZWNBSP>`   |
- * | Other category “Zs” | Any other Unicode “Space_Separator” code point | `<USP>`      |
- *
- * @param char
- * @returns {boolean}
- */
-function isWhitespaceCharacter(char) {
-  return whitespaceRegEx.test(char);
-}
+const {
+  isWhitespaceOrNewLineOnly,
+  isWhitespaceCharacterNoNewline,
+  cdlNewLineRegEx,
+} = require('./textUtils');
 
 /**
  * Strips and counts the indentation from the given string.
+ * This function is similar to the one in docCommentParser.js, but
+ * has special handling for the first and last line of the string.
  *
  * @example
  *     |        hello
@@ -58,10 +30,10 @@ function stripIndentation(str) {
   }
 
   // Note: We have to check all newline characters, as the string is not normalized, yet.
-  const lines = str.split(newLineRegEx);
+  const lines = str.split(cdlNewLineRegEx);
   const n = lines.length;
 
-  const hasTrailingLineBreak = newLineRegEx.test(str[str.length - 1]);
+  const hasTrailingLineBreak = cdlNewLineRegEx.test(str[str.length - 1]);
   if (hasTrailingLineBreak) {
     // Shortcut:
     // If there is a trailing line break, it means that ``` is on newline and
@@ -73,12 +45,12 @@ function stripIndentation(str) {
   const minIndent = lines.reduce((min, line, index) => {
     // Note: Last line is the line containing ```.  There, we always count the indentation,
     //       even if blank.  For all other lines, blank lines are ignored.
-    if (isWhiteSpaceOnly(line) && index !== (n-1))
+    if (isWhitespaceOrNewLineOnly(line) && index !== (n-1))
       return min;
 
     let count = 0;
     const length = Math.min(min, line.length);
-    while (count < length && isWhitespaceCharacter(line[count])) {
+    while (count < length && isWhitespaceCharacterNoNewline(line[count])) {
       count++;
     }
     return Math.min(min, count);
@@ -138,7 +110,7 @@ class MultiLineStringParser {
       // If there are no line breaks, emit an error as normal single-back-tick
       // strings should be used instead.  Because the first line is skipped,
       // there is no text without at least one line break.
-      if (!newLineRegEx.test(this.str)) {
+      if (!cdlNewLineRegEx.test(this.str)) {
         const loc = this._locationForCharacters(this.end, 1);
         this.parser.message('syntax-invalid-text-block', loc);
         return '';
@@ -300,7 +272,7 @@ class MultiLineStringParser {
     let codePoint = '';
 
     for (let j = 0; j < count; ++j) {
-      if (!this._eos() && /^[0-9A-Fa-f]$/.test(this._lookahead())) {
+      if (!this._eos() && /^[\dA-Fa-f]$/.test(this._lookahead())) {
         this._move();
         codePoint += this._current();
       } else {
@@ -330,7 +302,7 @@ class MultiLineStringParser {
     this._move(); // 'u'
 
     while (!this._eos()) {
-      if (/^[0-9A-Fa-f]$/.test(this._lookahead())) {
+      if (/^[\dA-Fa-f]$/.test(this._lookahead())) {
         this._move();
         codePoint += this._current();
       } else if (this._lookahead() === '}') {

package/lib/language/textUtils.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/** Whitespace characters without line-breaks. */
+const whitespaceRegEx = /[\t\u{000B}\u{000C} \u{00A0}\u{FEFF}\p{Zs}]/u;
+const cdlNewLineRegEx = /\r\n?|\n|\u2028|\u2029/u;
+
+/**
+ * Returns true if the given string only contains whitespace characters.
+ * In contrast to `whitespaceRegEx`, it also matches newlines.
+ *
+ * @param {string} str
+ * @returns {boolean}
+ */
+function isWhitespaceOrNewLineOnly(str) {
+  return /^\s*$/.test(str);
+}
+
+/**
+ * Check whether the given character is a white-space character as
+ * defined by §11.2 of the ECMAScript 2020 specification.
+ * See <https://262.ecma-international.org/11.0/#sec-white-space>.
+ *
+ * | Code Point          | Name                                           | Abbreviation |
+ * |:--------------------|:-----------------------------------------------|--------------|
+ * | U+0009              | CHARACTER TABULATION                           | `<TAB>`      |
+ * | U+000B              | LINE TABULATION                                | `<VT>`       |
+ * | U+000C              | FORM FEED (FF)                                 | `<FF>`       |
+ * | U+0020              | SPACE                                          | `<SP>`       |
+ * | U+00A0              | NO-BREAK SPACE                                 | `<NBSP>`     |
+ * | U+FEFF              | ZERO WIDTH NO-BREAK SPACE                      | `<ZWNBSP>`   |
+ * | Other category “Zs” | Any other Unicode “Space_Separator” code point | `<USP>`      |
+ *
+ * @param char
+ * @returns {boolean}
+ */
+function isWhitespaceCharacterNoNewline(char) {
+  return whitespaceRegEx.test(char);
+}
+
+module.exports = {
+  isWhitespaceOrNewLineOnly,
+  isWhitespaceCharacterNoNewline,
+  cdlNewLineRegEx,
+};

package/lib/main.d.ts

@@ -86,6 +86,15 @@ declare namespace compiler {
      * the prefix for SAP CDS packages / CDS files.
      */
     cdsHome?: string
+    /**
+     * When set to `true`, and the model contains an entity `sap.common.Languages`
+     * with an element `code`, all generated texts entities additionally contain
+     * an element `language` which is an association to `sap.common.Languages`
+     * using element `locale`.
+     *
+     * @since v2.8.0
+     */
+    addTextsLanguageAssoc?: boolean
     /**
      * Option for {@link compileSources}.  If set, all objects inside the
      * provided sources dictionary are interpreted as XSN structures instead
@@ -403,6 +412,10 @@ declare namespace compiler {
    * It could also be a simple string, which is then considered to be the source
    * text of a file named `<stdin>.cds`.
    *
+   * This function uses the direct value of USINGs (in CSN `"requires"`) for its dependency graph,
+   * i.e. this function does not resolve USINGs.  If a USING matches a key in sourcesDict,
+   * we assume that it depends on that file (/sourcesDict entry).
+   *
    * See function {@link compile} for the meaning of the argument `options`.  If there
    * are parse or other compilation errors, throws an exception {@link CompilationError}
    * containing a list of individual errors.
@@ -581,7 +594,6 @@ declare namespace compiler {
    *                     coloring will be used.  If 'auto', we will decide based on certain factors such
    *                     as whether the shell is a TTY and whether the environment variable `NO_COLOR` is
    *                     unset.
-
    */
   export function messageContext(sourceLines: string[], msg: CompileMessage, config?: {
     color?: boolean | 'auto'
@@ -608,25 +620,6 @@ declare namespace compiler {
    */
   export function hasErrors(messages: CompileMessage[]): boolean;
 
-  /**
-   * Same as {@link to.edm} but expects a {@link for.odata} transformed CSN.
-   *
-   * Note that parameter `service` is the same as `ODataOptions.service`.
-   * The latter is not used.  OData specific options have an internal format.
-   *
-   * @deprecated Use {@link to.edm} instead. If it detects a pre-transformed CSN, it won't run for.odata().
-   */
-  export function preparedCsnToEdm(csn: CSN, service: string, options: ODataOptions): object;
-  /**
-   * Same as {@link to.edm} but expects a {@link for.odata} transformed CSN.
-   *
-   * Note that parameter `service` is the same as `ODataOptions.service`.
-   * The latter is not used.  OData specific options have an outdated format.
-   *
-   * @deprecated Use {@link to.edmx} instead. If it detects a pre-transformed CSN, it won't run for.odata().
-   */
-  export function preparedCsnToEdmx(csn: CSN, service: string, options: ODataOptions): string;
-
   export namespace parse {
       /**
        * Parse the given CDL in parseCdl mode and return its corresponding CSN representation.
@@ -658,15 +651,6 @@ declare namespace compiler {
       function expr(cdl: string, filename?: string, options?: Options): CXN;
   }
 
-  /**
-   * @deprecated Use {@link parse.cql} instead.
-   */
-  export function parseToCqn(cql: string, filename?: string, options?: Options): CQN;
-  /**
-   * @deprecated Use {@link parse.expr} instead.
-   */
-  export function parseToExpr(expr: string, filename?: string, options?: Options): CXN;
-
   /**
    * @note Actual name is "for" which can't be used directly in the documentation
    *       as it is a reserved name in TypeScript.
@@ -812,7 +796,7 @@ declare namespace compiler {
     /**
      * Rendered csn.namespace property + using directives.
      */
-    [namespace: string]: string
+    namespace?: string
   }
 
   /**
@@ -857,20 +841,17 @@ declare namespace compiler {
    * - For the 'plain' naming mode, it means converting all `.` to `_` and upper-casing.
    * - For the 'quoted' naming mode, this means correctly replacing some `.` with `_`.
    *
+   * The above rules might differ for different SQL dialects.
+   * Exceptions will be listed below.
+   *
    * @param artifactName The fully qualified name of the artifact
    * @param sqlMapping The naming mode to use. See {@link SqlOptions.sqlMapping} for more details.
    * @param csn
+   * @param sqlDialect The SQL dialect to use. See {@link SqlOptions.sqlDialect} for more details.
    * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming mode.
    * @since v2.1.0
    */
-  export function getArtifactCdsPersistenceName(artifactName: string, sqlMapping: string, csn: CSN): string;
-  /**
-   * This is an old function signature.  If it is used - with a namespace as the third argument - the result might be wrong,
-   * since the `.` -> `_` conversion for 'quoted'/'hdbcds' is missing.
-   *
-   * @deprecated Use the other overload with CSN instead.
-   */
-  export function getArtifactCdsPersistenceName(artifactName: string, sqlMapping: string, namespace: string): string;
+  export function getArtifactCdsPersistenceName(artifactName: string, sqlMapping: string, csn: CSN, sqlDialect: string): string;
   /**
    *  Return the resulting database element name for `elemName`, depending on the current
    *  naming mode.
@@ -879,11 +860,15 @@ declare namespace compiler {
    *  - For the 'quoted' naming mode, it means converting all `.` to `_`.
    *  No other naming modes are accepted!
    *
+   * The above rules might differ for different SQL dialects.
+   * Exceptions will be listed below.
+   *
    * @param elemName The name of the element. For structured elements, concat by dot, e.g. `sub.elem`.
    * @param sqlMapping The naming mode to use. See {@link SqlOptions.sqlMapping} for more details.
+   * @param sqlDialect The SQL dialect to use. See {@link SqlOptions.sqlDialect} for more details.
    * @returns The resulting database element name for 'elemName', depending on the current naming mode.
    */
-  export function getElementCdsPersistenceName(elemName: string, sqlMapping: string): string;
+  export function getElementCdsPersistenceName(elemName: string, sqlMapping: string, sqlDialect: string): string;
 
   /**
    * Traverse the CSN node `csn`.
@@ -911,6 +896,7 @@ declare namespace compiler {
      * but not `cds.foundation.*`.
      *
      * @param definitionName Top-level definition name of the artifact.
+     * @since v2.14.0
      */
     function isInReservedNamespace(definitionName: string): boolean;
   }
@@ -1003,7 +989,7 @@ declare namespace compiler {
       }
     }
     /**
-     * String representation of the message.  May be a multi-line message in the future.
+     * String representation of the message.  It may be a multi-line message in the future.
      */
     message: string
     /**
@@ -1022,7 +1008,7 @@ declare namespace compiler {
      */
     error?: Error
     /**
-     * Returns a human readable string of the compiler message. Uses {@link messageString} to render
+     * Returns a human-readable string of the compiler message.  Uses {@link messageString} to render
      * the message without filename normalization and without a message ID.
      */
     toString(): string;
@@ -1054,7 +1040,7 @@ declare namespace compiler {
    *  - `false`: the file does not exist
    *  - `true`: file exists (fstat), no further knowledge yet - i.e. value will change!
    *  - `string` or `Buffer`: the file content
-   *  - `{ realname: fs.realpath(filename) }`: if filename is not canonicalized
+   *  - `{ realname: fs.realpath.native(filename) }`: if filename is not canonicalized
    */
   export type FileCache = Record<string, boolean | string | Buffer | { realname: string }>;
 

package/lib/main.js

@@ -13,70 +13,59 @@
 
 'use strict';
 
-const backends = require('./backends');
-const { odata, cdl, sql, hdi, hdbcds, edm, edmx } = require('./api/main');
-const { getArtifactDatabaseNameOf, getElementDatabaseNameOf } = require('./model/csnUtils');
-const { traverseCsn } = require('./model/api');
-const { createMessageFunctions, sortMessages, sortMessagesSeverityAware, deduplicateMessages } = require('./base/messages');
-const { smartId, smartFuncId, delimitedId } = require('./sql-identifier');
-const keywords = require( './base/keywords' );
-
-const parseLanguage = require('./language/antlrParser');
-const { parseX, compileX, compileSyncX, compileSourcesX, InvocationError } = require('./compiler');
-const { fns } = require('./compiler/shared');
-const define = require('./compiler/define');
-const { isInReservedNamespace } = require("./compiler/builtins");
-const finalizeParseCdl = require('./compiler/finalize-parse-cdl');
+const snapi = lazyload('./api/main');
+const csnUtils = lazyload('./model/csnUtils');
+const model_api = lazyload('./model/api');
+const messages = lazyload('./base/messages');
+const sqlIdentifier = lazyload('./sql-identifier');
+const keywords = lazyload( './base/keywords' );
+
+const parseLanguage = lazyload('./language/antlrParser');
+const compiler = lazyload('./compiler');
+const shared = lazyload('./compiler/shared');
+const define = lazyload('./compiler/define');
+const builtins = lazyload("./compiler/builtins");
+const finalizeParseCdl = lazyload('./compiler/finalize-parse-cdl');
 
 // The compiler version (taken from package.json)
 function version() {
   return require('../package.json').version;
 }
 
-const {
-  CompilationError,
-  messageString,
-  messageStringMultiline,
-  messageContext,
-  hasErrors,
-  explainMessage,
-  hasMessageExplanation
-} = require('./base/messages');
-
-const { compactModel, compactQuery, compactExpr } = require('./json/to-csn')
+const toCsn = lazyload('./json/to-csn')
 
 function parseCdl( cdlSource, filename, options = {} ) {
   options = Object.assign( {}, options, { parseCdl: true } );
   const sources = Object.create(null);
   /** @type {XSN.Model} */
   const model = { sources, options, $functions: {}, $volatileFunctions: {} };
-  const messageFunctions = createMessageFunctions( options, 'parse', model );
+  const messageFunctions = messages.createMessageFunctions( options, 'parse', model );
   model.$messageFunctions = messageFunctions;
 
   const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
                              messageFunctions );
   sources[filename] = xsn;
-  fns( model );
+  shared.fns( model );
   define( model );
   finalizeParseCdl( model );
   messageFunctions.throwWithError();
-  return compactModel( model );
+  return toCsn.compactModel( model );
 }
 
 function parseCql( cdlSource, filename = '<query>.cds', options = {} ) {
-  const messageFunctions = createMessageFunctions( options, 'parse' );
+  const messageFunctions = messages.createMessageFunctions( options, 'parse' );
   const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
                              messageFunctions, 'query' );
   messageFunctions.throwWithError();
-  return compactQuery( xsn );
+  return toCsn.compactQuery( xsn );
 }
 
 function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
-  const messageFunctions = createMessageFunctions( options, 'parse' );
+  const messageFunctions = messages.createMessageFunctions( options, 'parse' );
   const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
                              messageFunctions, 'expr' );
   messageFunctions.throwWithError();
-  return compactExpr( xsn );
+  return toCsn.compactExpr( xsn );
 }
 
 // FIXME: The implementation of those functions that delegate to 'backends' should probably move here
@@ -84,74 +73,108 @@ function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
 module.exports = {
   // Compiler
   version,
-  compile: (...args) => compileX(...args).then( compactModel ), // main function
-  compileSync: (filenames, dir, options, fileCache) => compactModel( compileSyncX(filenames, dir, options, fileCache) ), // main function
-  compileSources: (sourcesDict, options) => compactModel( compileSourcesX(sourcesDict, options) ), // main function
+  compile: (...args) => compiler.compileX(...args).then( toCsn.compactModel ), // main function
+  compileSync: (filenames, dir, options, fileCache) => toCsn.compactModel( compiler.compileSyncX(filenames, dir, options, fileCache) ), // main function
+  compileSources: (sourcesDict, options) => toCsn.compactModel( compiler.compileSourcesX(sourcesDict, options) ), // main function
   compactModel: csn => csn,     // for easy v2 migration
-  CompilationError,
-  sortMessages,
-  sortMessagesSeverityAware,
-  deduplicateMessages,
-  messageString,
-  messageStringMultiline,
-  messageContext,
-  explainMessage,
-  hasMessageExplanation,
-  InvocationError,    // TODO: make it no error if same file name is provided twice
-  hasErrors,
-
-  // Backends
-  // TODO: Expose when transformers are switched to CSN
-  // toOdataWithCsn: backends.toOdataWithCsn,
-  preparedCsnToEdmx : (csn, service, options) => { return backends.preparedCsnToEdmx(csn, service, options).edmx},
-  preparedCsnToEdm :  (csn, service, options) => { return backends.preparedCsnToEdm(csn, service, options).edmj},
+  get CompilationError() {
+    Object.defineProperty(this, "CompilationError", {
+      value: messages.CompilationError,
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+    return messages.CompilationError;
+  },
+  sortMessages: (...args) => messages.sortMessages(...args),
+  sortMessagesSeverityAware: (...args) => messages.sortMessagesSeverityAware(...args),
+  deduplicateMessages: (...args) => messages.deduplicateMessages(...args),
+  messageString: (...args) => messages.messageString(...args),
+  messageStringMultiline: (...args) => messages.messageStringMultiline(...args),
+  messageContext: (...args) => messages.messageContext(...args),
+  explainMessage: (...args) => messages.explainMessage(...args),
+  hasMessageExplanation: (...args) => messages.hasMessageExplanation(...args),
+  get InvocationError() {
+    Object.defineProperty(this, "InvocationError", {
+      value: compiler.InvocationError,
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+    return compiler.InvocationError;
+  },
+  hasErrors: (...args) => messages.hasErrors(...args),
 
   // additional API:
-  parse: { cdl: parseCdl, cql: parseCql, expr: parseExpr }, // preferred names
-  /**
-   * @deprecated Use parse.cql instead
-   */
-  parseToCqn: parseCql,
-  /**
-   * @deprecated Use parse.expr instead
-   */
-  parseToExpr: parseExpr,       // deprecated name
+  parse: { cdl: (...args) => parseCdl(...args), cql: (...args) => parseCql(...args), expr: (...args) => parseExpr(...args) },
   // SNAPI
-  for: { odata },
+  for: { odata: (...args) => snapi.odata(...args) },
   to: {
-    cdl: Object.assign(cdl, {
-      keywords: Object.freeze([ ...keywords.cdl ]),
-      functions: Object.freeze([ ...keywords.cdl_functions ]),
+    cdl: Object.assign((...args) => snapi.cdl(...args), {
+      keywords: Object.freeze([ ...keywords.cdl ] ),
+      functions: Object.freeze([ ...keywords.cdl_functions ] ),
+    }),
+    sql: Object.assign((...args) => snapi.sql(...args), {
+      sqlite: {
+        keywords: Object.freeze([ ...keywords.sqlite ] )
+      },
+      smartId: (...args) => sqlIdentifier.smartId(...args),
+      smartFunctionId: (...args) => sqlIdentifier.smartFuncId(...args),
+      delimitedId: (...args) => sqlIdentifier.delimitedId(...args),
     }),
-    sql: Object.assign(sql, {
-      sqlite: { keywords: Object.freeze([ ...keywords.sqlite ] )},
-      smartId,
-      smartFunctionId: smartFuncId,
-      delimitedId,
+    hdi: Object.assign((...args) => snapi.hdi(...args), {
+      migration: (...args) => snapi.hdi.migration(...args),
+      keywords: Object.freeze([ ...keywords.hana ] ),
     }),
-    hdi: Object.assign(hdi, {
-      keywords: Object.freeze([ ...keywords.hana ]),
+    hdbcds: Object.assign((...args) => snapi.hdbcds(...args), {
+      keywords: Object.freeze([ ...keywords.hdbcds ] ),
     }),
-    hdbcds: Object.assign(hdbcds, {
-      keywords: Object.freeze([ ...keywords.hdbcds ]),
+    edm: Object.assign((...args) => snapi.edm(...args), {
+      all: (...args) => snapi.edm.all(...args)
+    }),
+    edmx: Object.assign((...args) => snapi.edmx(...args), {
+      all: (...args) => snapi.edmx.all(...args)
     }),
-    edm,
-    edmx
   },
   // Convenience for hdbtabledata calculation in @sap/cds
-  getArtifactCdsPersistenceName: getArtifactDatabaseNameOf,
-  getElementCdsPersistenceName: getElementDatabaseNameOf,
+  getArtifactCdsPersistenceName: (...args) => csnUtils.getArtifactDatabaseNameOf(...args),
+  getElementCdsPersistenceName: (...args) => csnUtils.getElementDatabaseNameOf(...args),
 
   // Other API functions:
-  traverseCsn,
+  traverseCsn: (...args) => model_api.traverseCsn(...args),
 
   // INTERNAL functions for the cds-lsp package and friends - before you use
   // it, you MUST talk with us - there can be potential incompatibilities with
   // new releases (even having the same major version):
-  $lsp: { parse: parseX, compile: compileX, getArtifactName: a => a.name },
+  $lsp: { parse: (...args) => compiler.parseX(...args), compile: (...args) => compiler.compileX(...args), getArtifactName: a => a.name },
 
   // CSN Model related functionality
   model: {
-    isInReservedNamespace,
+    isInReservedNamespace: (...args) => builtins.isInReservedNamespace(...args),
   },
 };
+
+/**
+ * Load the module on-demand and not immediately.
+ *
+ * @param {string} moduleName Name of the module to load - like with require
+ * @returns {object} A Proxy that handles the on-demand loading
+ */
+function lazyload(moduleName) {
+  let module;
+  return new Proxy(((...args) => {
+    if (!module) // eslint-disable-next-line global-require
+      module = require(moduleName);
+
+    if (module.apply && typeof module.apply === 'function')
+      return module.apply(this, args);
+    return module; // for destructured calls
+  }), {
+    get(target, name) {
+      if (!module) // eslint-disable-next-line global-require
+        module = require(moduleName);
+
+      return module[name];
+    },
+  });
+}

package/lib/model/api.js

@@ -11,7 +11,7 @@
  * Each function in `userFunctions` and `defaultFunctions` is called with:
  * - `userFunctions`
  * - the current CSN node, i.e. ‹parent node›.‹property name›
- * - the the ‹parent node›
+ * - the ‹parent node›
  * - the ‹property name› (might be useful if the same function is used for several props)
  */
 const defaultFunctions = {