necessary 10.0.7 → 11.0.0

package/.rc

@@ -0,0 +1,23 @@
+{
+  "environments": [
+    {
+      "name": "production",
+      "nameCheck": [
+        "ENVIRONMENT"
+      ],
+      "liveReload": false,
+      "staticHost": "https://static.djalbat.com",
+      "enableStaticRouter": false
+    },
+    {
+      "name": "development",
+      "nameCheck": [
+        "ENVIRONMENT"
+      ],
+      "port": 8080,
+      "liveReload": true,
+      "staticHost": "http://localhost:8080",
+      "enableStaticRouter": true
+    }
+  ]
+}

package/README.md

@@ -437,19 +437,17 @@ const stats = getStats("root/etc"); // returns stats for the 'root/etc' director
 
 A single `rc()` function for runtime configuration.
 
-* The `rc()` function parses a JSON runtime configuration file of a certain format and provides the information therein by assigning it to itself:
+* The `rc()` function parses a JSON runtime configuration file of a certain format and provides the information therein by assigning it to itself. For example:
 
 ```
 rc();
 
 const { logOptions } = rc;
 
-setLogOptions(logOptions); // Expects a plain old JavaScript object of the form { level,
-                           //                                                     fileBaseName,
-                           //                                                     directoryPath }
+setLogOptions(logOptions);
 ```
 
-By default it will parse a file called `.rc` in the current working directory. This file should have the following format:
+The default name for the file is `.rc` and it must be present in the current working directory. It must have the following format:
 
 ```
 {
@@ -466,17 +464,16 @@ By default it will parse a file called `.rc` in the current working directory. T
 }
 ```
 
-In the absence of being passed an environment name, it will parse and return the first element of the `enviromnents` array. It will not try to assign the `name` property of the chosen environment to itself, by the way, because functions already have a `name` property. It can be instructed to a chose a specific environment thus:
+If an environment name is not passed as the `rc()` function's argument then it will try to find the environment name by the following means:
 
-```
-rc("production"); // Provides the 'production' environment
-```
+1. Checking the `process.argv` array for an `--environment` argument. 
+2. Checking the `proxess.env` object for an `ENVIRONMENT` environment variable.
 
-Or you can pass `process.argv` if the command line arguments include something of the form `--environment=...`:
+If neither of these checks are successful then it will return the first element of the `enviromnents` array. 
 
-```
-rc(process.argv); // Provides the 'development' if given '--environment=development'
-```
+Note that it will not try to assign the `name` property of the chosen environment to itself, because functions already have a `name` property.
+
+Before returning the JSON, it will search for uppercase strings. If such a string is the name of an environment variable, it will be replaced by the environment variable's value. This means that you can choose to keep sensitive information out of the runtime configuration and therefore, for instance, safely commit it to the repository. 
 
 You can change the base extension of the file that is parsed, that is the part of the extension between the leading dot and `rc`, by making use of the `setRCBaseExtension()` function:
 

package/lib/constants.js

@@ -2,18 +2,26 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.CONTENT_TYPE = exports.EMPTY_STRING = exports.ACCEPT = exports.CTRL_C = exports.ERROR = exports.UTF8 = void 0;
+exports.CONTENT_TYPE = exports.EMPTY_STRING = exports.ENVIRONMENT = exports.BOOLEAN = exports.NUMBER = exports.ACCEPT = exports.STRING = exports.CTRL_C = exports.ERROR = exports.UTF8 = void 0;
 var UTF8 = "utf8";
 exports.UTF8 = UTF8;
 var ERROR = "error";
 exports.ERROR = ERROR;
 var CTRL_C = "^C";
 exports.CTRL_C = CTRL_C;
+var STRING = "string";
+exports.STRING = STRING;
 var ACCEPT = "accept";
 exports.ACCEPT = ACCEPT;
+var NUMBER = "number";
+exports.NUMBER = NUMBER;
+var BOOLEAN = "boolean";
+exports.BOOLEAN = BOOLEAN;
+var ENVIRONMENT = "ENVIRONMENT";
+exports.ENVIRONMENT = ENVIRONMENT;
 var EMPTY_STRING = "";
 exports.EMPTY_STRING = EMPTY_STRING;
 var CONTENT_TYPE = "content-type";
 exports.CONTENT_TYPE = CONTENT_TYPE;
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jb25zdGFudHMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBjb25zdCBVVEY4ID0gXCJ1dGY4XCI7XG5leHBvcnQgY29uc3QgRVJST1IgPSBcImVycm9yXCI7XG5leHBvcnQgY29uc3QgQ1RSTF9DID0gXCJeQ1wiO1xuZXhwb3J0IGNvbnN0IEFDQ0VQVCA9IFwiYWNjZXB0XCI7XG5leHBvcnQgY29uc3QgRU1QVFlfU1RSSU5HID0gXCJcIjtcbmV4cG9ydCBjb25zdCBDT05URU5UX1RZUEUgPSBcImNvbnRlbnQtdHlwZVwiO1xuIl0sIm5hbWVzIjpbIlVURjgiLCJFUlJPUiIsIkNUUkxfQyIsIkFDQ0VQVCIsIkVNUFRZX1NUUklORyIsIkNPTlRFTlRfVFlQRSJdLCJtYXBwaW5ncyI6IkFBQUEsQ0FBWTs7Ozs7QUFFTCxHQUFLLENBQUNBLElBQUksR0FBRyxDQUFNO1FBQWJBLElBQUksR0FBSkEsSUFBSTtBQUNWLEdBQUssQ0FBQ0MsS0FBSyxHQUFHLENBQU87UUFBZkEsS0FBSyxHQUFMQSxLQUFLO0FBQ1gsR0FBSyxDQUFDQyxNQUFNLEdBQUcsQ0FBSTtRQUFiQSxNQUFNLEdBQU5BLE1BQU07QUFDWixHQUFLLENBQUNDLE1BQU0sR0FBRyxDQUFRO1FBQWpCQSxNQUFNLEdBQU5BLE1BQU07QUFDWixHQUFLLENBQUNDLFlBQVksR0FBRyxDQUFFO1FBQWpCQSxZQUFZLEdBQVpBLFlBQVk7QUFDbEIsR0FBSyxDQUFDQyxZQUFZLEdBQUcsQ0FBYztRQUE3QkEsWUFBWSxHQUFaQSxZQUFZIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jb25zdGFudHMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBjb25zdCBVVEY4ID0gXCJ1dGY4XCI7XG5leHBvcnQgY29uc3QgRVJST1IgPSBcImVycm9yXCI7XG5leHBvcnQgY29uc3QgQ1RSTF9DID0gXCJeQ1wiO1xuZXhwb3J0IGNvbnN0IFNUUklORyA9IFwic3RyaW5nXCI7XG5leHBvcnQgY29uc3QgQUNDRVBUID0gXCJhY2NlcHRcIjtcbmV4cG9ydCBjb25zdCBOVU1CRVIgPSBcIm51bWJlclwiO1xuZXhwb3J0IGNvbnN0IEJPT0xFQU4gPSBcImJvb2xlYW5cIjtcbmV4cG9ydCBjb25zdCBFTlZJUk9OTUVOVCA9IFwiRU5WSVJPTk1FTlRcIjtcbmV4cG9ydCBjb25zdCBFTVBUWV9TVFJJTkcgPSBcIlwiO1xuZXhwb3J0IGNvbnN0IENPTlRFTlRfVFlQRSA9IFwiY29udGVudC10eXBlXCI7XG4iXSwibmFtZXMiOlsiVVRGOCIsIkVSUk9SIiwiQ1RSTF9DIiwiU1RSSU5HIiwiQUNDRVBUIiwiTlVNQkVSIiwiQk9PTEVBTiIsIkVOVklST05NRU5UIiwiRU1QVFlfU1RSSU5HIiwiQ09OVEVOVF9UWVBFIl0sIm1hcHBpbmdzIjoiQUFBQSxDQUFZOzs7OztBQUVMLEdBQUssQ0FBQ0EsSUFBSSxHQUFHLENBQU07UUFBYkEsSUFBSSxHQUFKQSxJQUFJO0FBQ1YsR0FBSyxDQUFDQyxLQUFLLEdBQUcsQ0FBTztRQUFmQSxLQUFLLEdBQUxBLEtBQUs7QUFDWCxHQUFLLENBQUNDLE1BQU0sR0FBRyxDQUFJO1FBQWJBLE1BQU0sR0FBTkEsTUFBTTtBQUNaLEdBQUssQ0FBQ0MsTUFBTSxHQUFHLENBQVE7UUFBakJBLE1BQU0sR0FBTkEsTUFBTTtBQUNaLEdBQUssQ0FBQ0MsTUFBTSxHQUFHLENBQVE7UUFBakJBLE1BQU0sR0FBTkEsTUFBTTtBQUNaLEdBQUssQ0FBQ0MsTUFBTSxHQUFHLENBQVE7UUFBakJBLE1BQU0sR0FBTkEsTUFBTTtBQUNaLEdBQUssQ0FBQ0MsT0FBTyxHQUFHLENBQVM7UUFBbkJBLE9BQU8sR0FBUEEsT0FBTztBQUNiLEdBQUssQ0FBQ0MsV0FBVyxHQUFHLENBQWE7UUFBM0JBLFdBQVcsR0FBWEEsV0FBVztBQUNqQixHQUFLLENBQUNDLFlBQVksR0FBRyxDQUFFO1FBQWpCQSxZQUFZLEdBQVpBLFlBQVk7QUFDbEIsR0FBSyxDQUFDQyxZQUFZLEdBQUcsQ0FBYztRQUE3QkEsWUFBWSxHQUFaQSxZQUFZIn0=

package/lib/utilities/configuration.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _array = require("../utilities/array");
 var _defaults = require("../defaults");
+var _constants = require("../constants");
 var _fileSystem = require("../utilities/fileSystem");
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -13,6 +14,9 @@ function _instanceof(left, right) {
         return left instanceof right;
     }
 }
+var _typeof = function(obj) {
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
 if (!globalThis.rc) {
     globalThis.rc = _rc;
 }
@@ -22,28 +26,13 @@ var _default = {
 };
 exports.default = _default;
 var baseExtension = _defaults.DEFAULT_RC_BASE_EXTENSION;
-function _rc() {
-    var environmentNameOrArgv = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
-    var environment1, environmentName, environmentNameOrArgvArgv = _instanceof(environmentNameOrArgv, Array);
-    if (environmentNameOrArgvArgv) {
-        var argv = environmentNameOrArgv; ///
-        environmentName = environmentNameFromArgv(argv);
-    } else {
-        environmentName = environmentNameOrArgv; ///
-    }
-    var json = readRCFile(), environments = json.environments;
-    if (environmentName === null) {
-        var firstEnvironment = (0, _array).first(environments);
-        environment1 = firstEnvironment; ///
-    } else {
-        environment1 = environments.find(function(environment) {
-            var name = environment.name, found = name === environmentName;
-            return found;
-        });
-    }
-    delete environment1.name;
-    Object.assign(rc, environment1);
-    return environment1;
+function _rc(environmentName) {
+    environmentName = environmentName || environmentNameFromArgv() || environmentNameFromEnv(); ///
+    var json = readRCFile();
+    var environment = findEnvironment(json, environmentName);
+    json = environment; ///
+    replaceEnvironmentVariables(json);
+    Object.assign(rc, environment);
 }
 function readRCFile() {
     var rcFilePath = rcFilePathFromNothing(), rcFileContent = (0, _fileSystem).readFile(rcFilePath), json = JSON.parse(rcFileContent);
@@ -90,9 +79,34 @@ Object.assign(_rc, {
     createVacuousRCFile: createVacuousRCFile,
     setRCBaseExtension: setRCBaseExtension
 });
-function environmentNameFromArgv(argv) {
+function findEnvironment(json, environmentName) {
+    var environment1;
+    var environments = json.environments;
+    if (environmentName === null) {
+        var firstEnvironment = (0, _array).first(environments);
+        environment1 = firstEnvironment; ///
+    } else {
+        environment1 = environments.find(function(environment) {
+            var name = environment.name;
+            if (name === environmentName) {
+                return true;
+            }
+        });
+    }
+    delete environment1.name;
+    return environment1;
+}
+function rcFilePathFromNothing() {
+    var rcFilePath = "./.".concat(baseExtension, "rc");
+    return rcFilePath;
+}
+function environmentNameFromEnv() {
+    var environmentName = process.env[_constants.ENVIRONMENT] || null;
+    return environmentName;
+}
+function environmentNameFromArgv() {
     var environmentName = null;
-    argv.find(function(argument) {
+    process.argv.find(function(argument) {
         var matches = argument.match(/--environment=(.+)/), found = matches !== null;
         if (found) {
             var secondMatch = (0, _array).second(matches);
@@ -102,9 +116,73 @@ function environmentNameFromArgv(argv) {
     });
     return environmentName;
 }
-function rcFilePathFromNothing() {
-    var rcFilePath = "./.".concat(baseExtension, "rc");
-    return rcFilePath;
+function replaceEnvironmentVariable(string) {
+    var value = null;
+    var stringUpperCase = isStringUpperCase(string);
+    if (stringUpperCase) {
+        var name = string; ///
+        value = process.env[name] || null;
+    }
+    return value;
+}
+function replaceEnvironmentVariables(environment) {
+    var json = environment;
+    var jsonArray = isJSONArray(json), jsonObject = isJSONObject(json);
+    if (false) {
+    ///
+    } else if (jsonArray) {
+        var array = json, length = array.length;
+        for(var index = 0; index < length; index++){
+            var json1 = array[index], jsonString = isJSONString(json1);
+            if (jsonString) {
+                var string = json1, value = replaceEnvironmentVariable(string);
+                if (value !== null) {
+                    array[index] = value;
+                }
+            }
+        }
+    } else if (jsonObject) {
+        var object = json; ///
+        for(var name in object){
+            var json2 = object[name], jsonString1 = isJSONString(json2);
+            if (jsonString1) {
+                var string1 = json2, value1 = replaceEnvironmentVariable(string1); ///
+                if (value1 !== null) {
+                    object[name] = value1;
+                }
+            } else {
+                replaceEnvironmentVariables(json2);
+            }
+        }
+    }
+}
+function isJSONArray(json) {
+    var jsonArray = _instanceof(json, Array);
+    return jsonArray;
+}
+function isJSONObject(json) {
+    var jsonArray = isJSONArray(json), jsonPrimitive = isJSONPrimitive(json), jsonObject = !jsonArray && !jsonPrimitive;
+    return jsonObject;
+}
+function isJSONString(json) {
+    var jsonString = (typeof json === "undefined" ? "undefined" : _typeof(json)) === _constants.STRING;
+    return jsonString;
+}
+function isJSONNumber(json) {
+    var jsonNumber = (typeof json === "undefined" ? "undefined" : _typeof(json)) === _constants.NUMBER;
+    return jsonNumber;
+}
+function isJSONBoolean(json) {
+    var jsonBoolean = (typeof json === "undefined" ? "undefined" : _typeof(json)) === _constants.BOOLEAN;
+    return jsonBoolean;
+}
+function isJSONPrimitive(json) {
+    var jsonString = isJSONString(json), jsonNumber = isJSONNumber(json), jsonBoolean = isJSONBoolean(json), jsonPrimitive = jsonString || jsonNumber || jsonBoolean;
+    return jsonPrimitive;
+}
+function isStringUpperCase(string) {
+    var upperCaseString = string.toUpperCase(), stringUpperCase = string === upperCaseString;
+    return stringUpperCase;
 }
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utilities/configuration.js"],"sourcesContent":["\"use strict\";\n\nimport { first, second } from \"../utilities/array\";\nimport { DEFAULT_RC_BASE_EXTENSION } from \"../defaults\";\nimport { readFile, writeFile, checkFileExists } from \"../utilities/fileSystem\";\n\nif (!globalThis.rc) {\n  globalThis.rc = _rc;\n}\n\nconst { rc } = globalThis;\n\nexport default {\n  rc\n};\n\nlet baseExtension = DEFAULT_RC_BASE_EXTENSION;\n\nfunction _rc(environmentNameOrArgv = null) {\n  let environment,\n      environmentName,\n      environmentNameOrArgvArgv = (environmentNameOrArgv instanceof Array);\n\n  if (environmentNameOrArgvArgv) {\n    const argv = environmentNameOrArgv; ///\n\n    environmentName = environmentNameFromArgv(argv);\n  } else {\n    environmentName = environmentNameOrArgv;  ///\n  }\n\n  const json = readRCFile(),\n        { environments } = json;\n\n  if (environmentName === null) {\n    const firstEnvironment = first(environments);\n\n    environment = firstEnvironment; ///\n  } else {\n    environment = environments.find((environment) => {\n      const { name } = environment,\n            found = (name === environmentName);\n\n      return found;\n    });\n  }\n\n  delete environment.name;\n\n  Object.assign(rc, environment);\n\n  return environment;\n}\n\nfunction readRCFile() {\n  const rcFilePath = rcFilePathFromNothing(),\n        rcFileContent = readFile(rcFilePath),\n        json = JSON.parse(rcFileContent);\n\n  return json;      \n}\n\nfunction writeRCFile(json) {\n  const rcFilePath = rcFilePathFromNothing(),\n        rdFileContent = JSON.stringify(json, null, \"  \");\n\n  writeFile(rcFilePath, rdFileContent);\n}\n\nfunction updateRCFile(addedProperties, ...deletedPropertyNames) {\n  let json = readRCFile();\n\n  if (addedProperties) {\n    Object.assign(json, addedProperties);\n  }\n\n  deletedPropertyNames.forEach((deletedPropertyName) => {\n    delete json[deletedPropertyName];\n  });\n\n  writeRCFile(json);      \n}\n\nfunction checkRCFileExists() {\n  const rcFilePath = rcFilePathFromNothing(),\n        rcFileExists = checkFileExists(rcFilePath);\n\n  return rcFileExists;\n}\n\nfunction createVacuousRCFile() {\n  const json = {\n    \"environments\": [\n      {}\n    ]\n  };\n\n  writeRCFile(json);\n}\n\nfunction setRCBaseExtension(rcBaseExtension) { baseExtension = rcBaseExtension; }\n\nObject.assign(_rc, {\n  readRCFile,\n  writeRCFile,\n  updateRCFile,\n  checkRCFileExists,\n  createVacuousRCFile,\n  setRCBaseExtension\n});\n\nfunction environmentNameFromArgv(argv) {\n  let environmentName = null;\n\n  argv.find((argument) => {  ///\n    const matches = argument.match(/--environment=(.+)/),\n          found = (matches !== null);\n\n    if (found) {\n      const secondMatch = second(matches);\n\n      environmentName = secondMatch;\n    }\n\n    return found;\n  });\n\n  return environmentName;\n}\n\nfunction rcFilePathFromNothing() {\n  const rcFilePath = `./.${baseExtension}rc`;\n\n  return rcFilePath;\n}\n"],"names":["globalThis","rc","_rc","baseExtension","environmentNameOrArgv","environment","environmentName","environmentNameOrArgvArgv","Array","argv","environmentNameFromArgv","json","readRCFile","environments","firstEnvironment","find","name","found","Object","assign","rcFilePath","rcFilePathFromNothing","rcFileContent","JSON","parse","writeRCFile","rdFileContent","stringify","updateRCFile","addedProperties","deletedPropertyNames","forEach","deletedPropertyName","checkRCFileExists","rcFileExists","createVacuousRCFile","setRCBaseExtension","rcBaseExtension","argument","matches","match","secondMatch"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utilities/configuration.js"],"sourcesContent":["\"use strict\";\n\nimport { first, second } from \"../utilities/array\";\nimport { DEFAULT_RC_BASE_EXTENSION } from \"../defaults\";\nimport { STRING, NUMBER, BOOLEAN, ENVIRONMENT } from \"../constants\";\nimport { readFile, writeFile, checkFileExists } from \"../utilities/fileSystem\";\n\nif (!globalThis.rc) {\n  globalThis.rc = _rc;\n}\n\nconst { rc } = globalThis;\n\nexport default {\n  rc\n};\n\nlet baseExtension = DEFAULT_RC_BASE_EXTENSION;\n\nfunction _rc(environmentName) {\n  environmentName = environmentName || environmentNameFromArgv() || environmentNameFromEnv(); ///\n\n  let json = readRCFile();\n\n  const environment = findEnvironment(json, environmentName);\n\n  json = environment; ///\n\n  replaceEnvironmentVariables(json);\n\n  Object.assign(rc, environment);\n}\n\nfunction readRCFile() {\n  const rcFilePath = rcFilePathFromNothing(),\n        rcFileContent = readFile(rcFilePath),\n        json = JSON.parse(rcFileContent);\n\n  return json;      \n}\n\nfunction writeRCFile(json) {\n  const rcFilePath = rcFilePathFromNothing(),\n        rdFileContent = JSON.stringify(json, null, \"  \");\n\n  writeFile(rcFilePath, rdFileContent);\n}\n\nfunction updateRCFile(addedProperties, ...deletedPropertyNames) {\n  let json = readRCFile();\n\n  if (addedProperties) {\n    Object.assign(json, addedProperties);\n  }\n\n  deletedPropertyNames.forEach((deletedPropertyName) => {\n    delete json[deletedPropertyName];\n  });\n\n  writeRCFile(json);      \n}\n\nfunction checkRCFileExists() {\n  const rcFilePath = rcFilePathFromNothing(),\n        rcFileExists = checkFileExists(rcFilePath);\n\n  return rcFileExists;\n}\n\nfunction createVacuousRCFile() {\n  const json = {\n    \"environments\": [\n      {}\n    ]\n  };\n\n  writeRCFile(json);\n}\n\nfunction setRCBaseExtension(rcBaseExtension) { baseExtension = rcBaseExtension; }\n\nObject.assign(_rc, {\n  readRCFile,\n  writeRCFile,\n  updateRCFile,\n  checkRCFileExists,\n  createVacuousRCFile,\n  setRCBaseExtension\n});\n\nfunction findEnvironment(json, environmentName) {\n  let environment;\n  const { environments } = json;\n\n  if (environmentName === null) {\n    const firstEnvironment = first(environments);\n\n    environment = firstEnvironment; ///\n  } else {\n    environment = environments.find((environment) => {\n      const { name } = environment;\n\n      if(name === environmentName) {\n        return true;\n      }\n    });\n  }\n\n  delete environment.name\n\n  return environment;\n}\n\nfunction rcFilePathFromNothing() {\n  const rcFilePath = `./.${baseExtension}rc`;\n\n  return rcFilePath;\n}\n\nfunction environmentNameFromEnv() {\n  const environmentName = process.env[ENVIRONMENT] || null;\n\n  return environmentName;\n}\n\nfunction environmentNameFromArgv() {\n  let environmentName = null;\n\n  process.argv.find((argument) => {  ///\n    const matches = argument.match(/--environment=(.+)/),\n          found = (matches !== null);\n\n    if (found) {\n      const secondMatch = second(matches);\n\n      environmentName = secondMatch;\n    }\n\n    return found;\n  });\n\n  return environmentName;\n}\n\nfunction replaceEnvironmentVariable(string) {\n  let value = null;\n\n  const stringUpperCase = isStringUpperCase(string);\n\n  if (stringUpperCase) {\n    const name = string;  ///\n\n    value = process.env[name] || null;\n  }\n\n  return value;\n}\n\nfunction replaceEnvironmentVariables(environment) {\n  let json = environment;\n\n  const jsonArray = isJSONArray(json),\n        jsonObject = isJSONObject(json);\n\n  if (false) {\n    ///\n  } else if (jsonArray) {\n    const array = json,\n          length = array.length;\n\n    for (let index = 0; index < length; index++) {\n      const json = array[index],\n            jsonString = isJSONString(json);\n\n      if (jsonString) {\n        const string = json,\n              value = replaceEnvironmentVariable(string);\n\n        if (value !== null) {\n          array[index] = value;\n        }\n      }\n    }\n  } else if (jsonObject) {\n    const object = json;  ///\n\n    for (let name in object) {\n      const json = object[name],\n            jsonString = isJSONString(json);\n\n      if (jsonString) {\n        const string = json,  ///\n              value = replaceEnvironmentVariable(string);  ///\n\n        if (value !== null) {\n          object[name] = value;\n        }\n      } else  {\n        replaceEnvironmentVariables(json);\n      }\n    }\n  }\n}\n\nfunction isJSONArray(json) {\n  const jsonArray = (json instanceof Array);\n\n  return jsonArray;\n}\n\nfunction isJSONObject(json) {\n  const jsonArray = isJSONArray(json),\n        jsonPrimitive = isJSONPrimitive(json),\n        jsonObject = (!jsonArray && ! jsonPrimitive);\n\n  return jsonObject;\n}\n\nfunction isJSONString(json) {\n  const jsonString = (typeof json === STRING);\n\n  return jsonString;\n}\n\nfunction isJSONNumber(json) {\n  const jsonNumber = (typeof json === NUMBER);\n\n  return jsonNumber;\n}\n\nfunction isJSONBoolean(json) {\n  const jsonBoolean = (typeof json === BOOLEAN);\n\n  return jsonBoolean;\n}\n\nfunction isJSONPrimitive(json) {\n  const jsonString = isJSONString(json),\n        jsonNumber = isJSONNumber(json),\n        jsonBoolean = isJSONBoolean(json),\n        jsonPrimitive = (jsonString || jsonNumber || jsonBoolean);\n\n  return jsonPrimitive;\n}\n\nfunction isStringUpperCase(string) {\n  const upperCaseString = string.toUpperCase(),\n        stringUpperCase = (string === upperCaseString);\n\n  return stringUpperCase;\n}\n"],"names":["globalThis","rc","_rc","baseExtension","environmentName","environmentNameFromArgv","environmentNameFromEnv","json","readRCFile","environment","findEnvironment","replaceEnvironmentVariables","Object","assign","rcFilePath","rcFilePathFromNothing","rcFileContent","JSON","parse","writeRCFile","rdFileContent","stringify","updateRCFile","addedProperties","deletedPropertyNames","forEach","deletedPropertyName","checkRCFileExists","rcFileExists","createVacuousRCFile","setRCBaseExtension","rcBaseExtension","environments","firstEnvironment","find","name","process","env","argv","argument","matches","match","found","secondMatch","replaceEnvironmentVariable","string","value","stringUpperCase","isStringUpperCase","jsonArray","isJSONArray","jsonObject","isJSONObject","array","length","index","jsonString","isJSONString","object","Array","jsonPrimitive","isJSONPrimitive","isJSONNumber","jsonNumber","isJSONBoolean","jsonBoolean","upperCaseString","toUpperCase"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "necessary",
   "author": "James Smith",
-  "version": "10.0.7",
+  "version": "11.0.0",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/necessary",
   "description": "A collection of utility functions.",

package/src/constants.js

@@ -3,6 +3,10 @@
 export const UTF8 = "utf8";
 export const ERROR = "error";
 export const CTRL_C = "^C";
+export const STRING = "string";
 export const ACCEPT = "accept";
+export const NUMBER = "number";
+export const BOOLEAN = "boolean";
+export const ENVIRONMENT = "ENVIRONMENT";
 export const EMPTY_STRING = "";
 export const CONTENT_TYPE = "content-type";

package/src/utilities/configuration.js

@@ -2,6 +2,7 @@
 
 import { first, second } from "../utilities/array";
 import { DEFAULT_RC_BASE_EXTENSION } from "../defaults";
+import { STRING, NUMBER, BOOLEAN, ENVIRONMENT } from "../constants";
 import { readFile, writeFile, checkFileExists } from "../utilities/fileSystem";
 
 if (!globalThis.rc) {
@@ -16,40 +17,18 @@ export default {
 
 let baseExtension = DEFAULT_RC_BASE_EXTENSION;
 
-function _rc(environmentNameOrArgv = null) {
-  let environment,
-      environmentName,
-      environmentNameOrArgvArgv = (environmentNameOrArgv instanceof Array);
+function _rc(environmentName) {
+  environmentName = environmentName || environmentNameFromArgv() || environmentNameFromEnv(); ///
 
-  if (environmentNameOrArgvArgv) {
-    const argv = environmentNameOrArgv; ///
-
-    environmentName = environmentNameFromArgv(argv);
-  } else {
-    environmentName = environmentNameOrArgv;  ///
-  }
-
-  const json = readRCFile(),
-        { environments } = json;
-
-  if (environmentName === null) {
-    const firstEnvironment = first(environments);
+  let json = readRCFile();
 
-    environment = firstEnvironment; ///
-  } else {
-    environment = environments.find((environment) => {
-      const { name } = environment,
-            found = (name === environmentName);
+  const environment = findEnvironment(json, environmentName);
 
-      return found;
-    });
-  }
+  json = environment; ///
 
-  delete environment.name;
+  replaceEnvironmentVariables(json);
 
   Object.assign(rc, environment);
-
-  return environment;
 }
 
 function readRCFile() {
@@ -109,10 +88,45 @@ Object.assign(_rc, {
   setRCBaseExtension
 });
 
-function environmentNameFromArgv(argv) {
+function findEnvironment(json, environmentName) {
+  let environment;
+  const { environments } = json;
+
+  if (environmentName === null) {
+    const firstEnvironment = first(environments);
+
+    environment = firstEnvironment; ///
+  } else {
+    environment = environments.find((environment) => {
+      const { name } = environment;
+
+      if(name === environmentName) {
+        return true;
+      }
+    });
+  }
+
+  delete environment.name
+
+  return environment;
+}
+
+function rcFilePathFromNothing() {
+  const rcFilePath = `./.${baseExtension}rc`;
+
+  return rcFilePath;
+}
+
+function environmentNameFromEnv() {
+  const environmentName = process.env[ENVIRONMENT] || null;
+
+  return environmentName;
+}
+
+function environmentNameFromArgv() {
   let environmentName = null;
 
-  argv.find((argument) => {  ///
+  process.argv.find((argument) => {  ///
     const matches = argument.match(/--environment=(.+)/),
           found = (matches !== null);
 
@@ -128,8 +142,110 @@ function environmentNameFromArgv(argv) {
   return environmentName;
 }
 
-function rcFilePathFromNothing() {
-  const rcFilePath = `./.${baseExtension}rc`;
+function replaceEnvironmentVariable(string) {
+  let value = null;
 
-  return rcFilePath;
+  const stringUpperCase = isStringUpperCase(string);
+
+  if (stringUpperCase) {
+    const name = string;  ///
+
+    value = process.env[name] || null;
+  }
+
+  return value;
+}
+
+function replaceEnvironmentVariables(environment) {
+  let json = environment;
+
+  const jsonArray = isJSONArray(json),
+        jsonObject = isJSONObject(json);
+
+  if (false) {
+    ///
+  } else if (jsonArray) {
+    const array = json,
+          length = array.length;
+
+    for (let index = 0; index < length; index++) {
+      const json = array[index],
+            jsonString = isJSONString(json);
+
+      if (jsonString) {
+        const string = json,
+              value = replaceEnvironmentVariable(string);
+
+        if (value !== null) {
+          array[index] = value;
+        }
+      }
+    }
+  } else if (jsonObject) {
+    const object = json;  ///
+
+    for (let name in object) {
+      const json = object[name],
+            jsonString = isJSONString(json);
+
+      if (jsonString) {
+        const string = json,  ///
+              value = replaceEnvironmentVariable(string);  ///
+
+        if (value !== null) {
+          object[name] = value;
+        }
+      } else  {
+        replaceEnvironmentVariables(json);
+      }
+    }
+  }
+}
+
+function isJSONArray(json) {
+  const jsonArray = (json instanceof Array);
+
+  return jsonArray;
+}
+
+function isJSONObject(json) {
+  const jsonArray = isJSONArray(json),
+        jsonPrimitive = isJSONPrimitive(json),
+        jsonObject = (!jsonArray && ! jsonPrimitive);
+
+  return jsonObject;
+}
+
+function isJSONString(json) {
+  const jsonString = (typeof json === STRING);
+
+  return jsonString;
+}
+
+function isJSONNumber(json) {
+  const jsonNumber = (typeof json === NUMBER);
+
+  return jsonNumber;
+}
+
+function isJSONBoolean(json) {
+  const jsonBoolean = (typeof json === BOOLEAN);
+
+  return jsonBoolean;
+}
+
+function isJSONPrimitive(json) {
+  const jsonString = isJSONString(json),
+        jsonNumber = isJSONNumber(json),
+        jsonBoolean = isJSONBoolean(json),
+        jsonPrimitive = (jsonString || jsonNumber || jsonBoolean);
+
+  return jsonPrimitive;
+}
+
+function isStringUpperCase(string) {
+  const upperCaseString = string.toUpperCase(),
+        stringUpperCase = (string === upperCaseString);
+
+  return stringUpperCase;
 }