@decaf-ts/utils
Version:
module management utils for decaf-ts
103 lines • 12.3 kB
JavaScript
import { toENVFormat } from "./text.js";
import { isBrowser } from "./web.js";
import { ObjectAccumulator } from "typed-object-accumulator";
/**
* @class Environment
* @extends {ObjectAccumulator<T>}
* @template T
* @description A class representing an environment with accumulation capabilities.
* @summary Manages environment-related data and provides methods for accumulation and key retrieval.
* @param {T} [initialData] - The initial data to populate the environment with.
*/
export class Environment extends ObjectAccumulator {
/**
* @static
* @protected
* @description A factory function for creating Environment instances.
* @summary Defines how new instances of the Environment class should be created.
* @return {Environment<any>} A new instance of the Environment class.
*/
static { this.factory = () => new Environment(); }
constructor() {
super();
}
/**
* @description Retrieves a value from the environment
* @summary Gets a value from the environment variables, handling browser and Node.js environments differently
* @param {string} k - The key to retrieve from the environment
* @return {unknown} The value from the environment, or undefined if not found
*/
fromEnv(k) {
let env;
if (isBrowser()) {
env = globalThis["ENV"];
}
else {
env = globalThis.process.env;
k = toENVFormat(k);
}
return env[k];
}
/**
* @description Expands an object into the environment
* @summary Defines properties on the environment object that can be accessed as getters and setters
* @template V - Type of the object being expanded
* @param {V} value - The object to expand into the environment
* @return {void}
*/
expand(value) {
Object.entries(value).forEach(([k, v]) => {
Object.defineProperty(this, k, {
get: () => {
const fromEnv = this.fromEnv(k);
return typeof fromEnv === "undefined" ? v : fromEnv;
},
set: (val) => {
v = val;
},
configurable: true,
enumerable: true,
});
});
}
/**
* @protected
* @static
* @description Retrieves or creates the singleton instance of the Environment class.
* @summary Ensures only one instance of the Environment class exists.
* @template E
* @param {...unknown[]} args - Arguments to pass to the factory function if a new instance is created.
* @return {E} The singleton instance of the Environment class.
*/
static instance(...args) {
Environment._instance = !Environment._instance
? Environment.factory(...args)
: Environment._instance;
return Environment._instance;
}
/**
* @static
* @description Accumulates the given value into the environment.
* @summary Adds new properties to the environment from the provided object.
* @template V
* @param {V} value - The object to accumulate into the environment.
* @return {V} The updated environment instance.
*/
static accumulate(value) {
const instance = Environment.instance();
return instance.accumulate(value);
}
/**
* @static
* @description Retrieves the keys of the environment, optionally converting them to ENV format.
* @summary Gets all keys in the environment, with an option to format them for environment variables.
* @param {boolean} [toEnv=true] - Whether to convert the keys to ENV format.
* @return {string[]} An array of keys from the environment.
*/
static keys(toEnv = true) {
return Environment.instance()
.keys()
.map((k) => (toEnv ? toENVFormat(k) : k));
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../src/utils/environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,kBAAe;AAErC,OAAO,EAAE,SAAS,EAAE,iBAAc;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,OAAO,WAA8B,SAAQ,iBAAoB;IACrE;;;;;;OAMG;aACc,YAAO,GACtB,GAAqB,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC;IAU5C;QACE,KAAK,EAAE,CAAC;IACV,CAAC;IAED;;;;;OAKG;IACO,OAAO,CAAC,CAAS;QACzB,IAAI,GAA4B,CAAC;QACjC,IAAI,SAAS,EAAE,EAAE,CAAC;YAChB,GAAG,GAAI,UAA+D,CACpE,KAAK,CACN,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,GAAG,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC;YAC7B,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;QACD,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACgB,MAAM,CAAmB,KAAQ;QAClD,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;YACvC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE;gBAC7B,GAAG,EAAE,GAAG,EAAE;oBACR,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;oBAChC,OAAO,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;gBACtD,CAAC;gBACD,GAAG,EAAE,CAAC,GAAe,EAAE,EAAE;oBACvB,CAAC,GAAG,GAAG,CAAC;gBACV,CAAC;gBACD,YAAY,EAAE,IAAI;gBAClB,UAAU,EAAE,IAAI;aACjB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACO,MAAM,CAAC,QAAQ,CAA6B,GAAG,IAAe;QACtE,WAAW,CAAC,SAAS,GAAG,CAAC,WAAW,CAAC,SAAS;YAC5C,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;YAC9B,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC;QAC1B,OAAO,WAAW,CAAC,SAAc,CAAC;IACpC,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CACf,KAAQ;QAIR,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,EAAE,CAAC;QACxC,OAAO,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,QAAiB,IAAI;QAC/B,OAAO,WAAW,CAAC,QAAQ,EAAE;aAC1B,IAAI,EAAE;aACN,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC","sourcesContent":["import { toENVFormat } from \"./text\";\nimport { EnvironmentFactory } from \"./types\";\nimport { isBrowser } from \"./web\";\nimport { ObjectAccumulator } from \"typed-object-accumulator\";\n\n/**\n * @class Environment\n * @extends {ObjectAccumulator<T>}\n * @template T\n * @description A class representing an environment with accumulation capabilities.\n * @summary Manages environment-related data and provides methods for accumulation and key retrieval.\n * @param {T} [initialData] - The initial data to populate the environment with.\n */\nexport class Environment<T extends object> extends ObjectAccumulator<T> {\n  /**\n   * @static\n   * @protected\n   * @description A factory function for creating Environment instances.\n   * @summary Defines how new instances of the Environment class should be created.\n   * @return {Environment<any>} A new instance of the Environment class.\n   */\n  protected static factory: EnvironmentFactory<any, any> =\n    (): Environment<any> => new Environment();\n\n  /**\n   * @static\n   * @private\n   * @description The singleton instance of the Environment class.\n   * @type {Environment<any>}\n   */\n  private static _instance: Environment<any>;\n\n  protected constructor() {\n    super();\n  }\n\n  /**\n   * @description Retrieves a value from the environment\n   * @summary Gets a value from the environment variables, handling browser and Node.js environments differently\n   * @param {string} k - The key to retrieve from the environment\n   * @return {unknown} The value from the environment, or undefined if not found\n   */\n  protected fromEnv(k: string) {\n    let env: Record<string, unknown>;\n    if (isBrowser()) {\n      env = (globalThis as typeof globalThis & { ENV: Record<string, any> })[\n        \"ENV\"\n      ];\n    } else {\n      env = globalThis.process.env;\n      k = toENVFormat(k);\n    }\n    return env[k];\n  }\n\n  /**\n   * @description Expands an object into the environment\n   * @summary Defines properties on the environment object that can be accessed as getters and setters\n   * @template V - Type of the object being expanded\n   * @param {V} value - The object to expand into the environment\n   * @return {void}\n   */\n  protected override expand<V extends object>(value: V): void {\n    Object.entries(value).forEach(([k, v]) => {\n      Object.defineProperty(this, k, {\n        get: () => {\n          const fromEnv = this.fromEnv(k);\n          return typeof fromEnv === \"undefined\" ? v : fromEnv;\n        },\n        set: (val: V[keyof V]) => {\n          v = val;\n        },\n        configurable: true,\n        enumerable: true,\n      });\n    });\n  }\n\n  /**\n   * @protected\n   * @static\n   * @description Retrieves or creates the singleton instance of the Environment class.\n   * @summary Ensures only one instance of the Environment class exists.\n   * @template E\n   * @param {...unknown[]} args - Arguments to pass to the factory function if a new instance is created.\n   * @return {E} The singleton instance of the Environment class.\n   */\n  protected static instance<E extends Environment<any>>(...args: unknown[]): E {\n    Environment._instance = !Environment._instance\n      ? Environment.factory(...args)\n      : Environment._instance;\n    return Environment._instance as E;\n  }\n\n  /**\n   * @static\n   * @description Accumulates the given value into the environment.\n   * @summary Adds new properties to the environment from the provided object.\n   * @template V\n   * @param {V} value - The object to accumulate into the environment.\n   * @return {V} The updated environment instance.\n   */\n  static accumulate<V extends object>(\n    value: V\n  ): typeof Environment._instance &\n    V &\n    ObjectAccumulator<typeof Environment._instance & V> {\n    const instance = Environment.instance();\n    return instance.accumulate(value);\n  }\n\n  /**\n   * @static\n   * @description Retrieves the keys of the environment, optionally converting them to ENV format.\n   * @summary Gets all keys in the environment, with an option to format them for environment variables.\n   * @param {boolean} [toEnv=true] - Whether to convert the keys to ENV format.\n   * @return {string[]} An array of keys from the environment.\n   */\n  static keys(toEnv: boolean = true): string[] {\n    return Environment.instance()\n      .keys()\n      .map((k) => (toEnv ? toENVFormat(k) : k));\n  }\n}\n"]}