@autometa/config 0.0.0

package/.eslintignore

@@ -0,0 +1,3 @@
+/dist
+/out
+node_modules

package/.eslintrc.cjs

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["custom"],
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) undefined Ben Aherne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Introduction
+
+There's nothing here yet

package/dist/esm/index.js

@@ -0,0 +1,130 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/config-object.ts
+import { AutomationError, raise } from "@autometa/errors";
+
+// src/environment-reader.ts
+var _envVar, _factory, _literal;
+var EnvironmentReader = class {
+  constructor() {
+    __privateAdd(this, _envVar, void 0);
+    __privateAdd(this, _factory, void 0);
+    __privateAdd(this, _literal, void 0);
+  }
+  /**
+   * Returns the configuration object for the selected
+   * environment by weighting.
+   * 
+   * By priority the environment is selected by:
+   * 1. Literal
+   * 2. Environment Variable
+   * 3. Factory
+   */
+  get value() {
+    if (__privateGet(this, _literal)) {
+      return __privateGet(this, _literal);
+    }
+    if (__privateGet(this, _envVar)) {
+      const value = process.env[__privateGet(this, _envVar)];
+      if (value) {
+        return value;
+      }
+    }
+    if (__privateGet(this, _factory)) {
+      return __privateGet(this, _factory).call(this);
+    }
+  }
+  byEnvironmentVariable(envVar) {
+    __privateSet(this, _envVar, envVar);
+    return this;
+  }
+  byFactory(factory) {
+    __privateSet(this, _factory, factory);
+    return this;
+  }
+  byLiteral(literal) {
+    __privateSet(this, _literal, literal);
+    return this;
+  }
+};
+_envVar = new WeakMap();
+_factory = new WeakMap();
+_literal = new WeakMap();
+
+// src/config-object.ts
+var Config = class {
+  constructor(envMap) {
+    this.envMap = envMap;
+    this.environments = new EnvironmentReader();
+  }
+  get current() {
+    const key = this.environments.value;
+    if (!key) {
+      if (!this.envMap.has("default")) {
+        throw new AutomationError(
+          `No environment is defined. Define an environment with 'env.byLiteral("my-environment")' or 'env.byEnvironmentVariable("MY_ENVIRONMENT")' or 'env.byFactory(() => "my-environment")' or 'env.byLiteral("default")'`
+        );
+      }
+      return this.envMap.get("default");
+    }
+    if (!this.envMap.has(key)) {
+      throw new AutomationError(
+        `Environment ${key} is not defined. Options are: 
+ ${Object.keys(
+          this.envMap
+        ).join("\n")}`
+      );
+    }
+    return this.envMap.get(key) ?? raise(`Environment ${key} is not defined`);
+  }
+};
+
+// src/define-config.ts
+import { AutomationError as AutomationError2 } from "@autometa/errors";
+function defineConfig(config, ...configs) {
+  const envs = [];
+  const envMap = config.envMap;
+  for (const config2 of configs) {
+    if (config2.environment) {
+      if (envs.includes(config2.environment)) {
+        throw new AutomationError2(
+          `Environment ${config2.environment} is defined more than once`
+        );
+      }
+      envMap.set(config2.environment, config2);
+      envs.push(config2.environment);
+    } else if (!config2.environment && envs.includes("default")) {
+      throw new AutomationError2(`Only one default environment can be defined`);
+    } else {
+      envMap.set("default", config2);
+      envs.push("default");
+      config2.environment = "default";
+    }
+  }
+  const setters = config.environments;
+  return {
+    env: setters
+  };
+}
+export {
+  Config,
+  EnvironmentReader,
+  defineConfig
+};

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+declare class EnvironmentReader {
+    #private;
+    /**
+     * Returns the configuration object for the selected
+     * environment by weighting.
+     *
+     * By priority the environment is selected by:
+     * 1. Literal
+     * 2. Environment Variable
+     * 3. Factory
+     */
+    get value(): string | undefined;
+    byEnvironmentVariable(envVar: string): this;
+    byFactory(factory: () => string): this;
+    byLiteral(literal: string): this;
+}
+
+type TestExecutorConfig = {
+    runner: "jest" | "vitest";
+    environment?: string;
+    test?: {
+        timeout?: number;
+        tagFilter?: string;
+    };
+};
+
+declare class Config {
+    envMap: Map<string, TestExecutorConfig>;
+    readonly environments: EnvironmentReader;
+    constructor(envMap: Map<string, TestExecutorConfig>);
+    get current(): TestExecutorConfig | undefined;
+}
+
+declare function defineConfig(config: Config, ...configs: TestExecutorConfig[]): {
+    env: {
+        byLiteral: (literal: string) => EnvironmentReader;
+        byEnvironmentVariable: (literal: string) => EnvironmentReader;
+        byFactory: (literal: () => string) => EnvironmentReader;
+    };
+};
+
+export { Config, EnvironmentReader, TestExecutorConfig, defineConfig };

package/dist/index.js

@@ -0,0 +1,158 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  EnvironmentReader: () => EnvironmentReader,
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config-object.ts
+var import_errors = require("@autometa/errors");
+
+// src/environment-reader.ts
+var _envVar, _factory, _literal;
+var EnvironmentReader = class {
+  constructor() {
+    __privateAdd(this, _envVar, void 0);
+    __privateAdd(this, _factory, void 0);
+    __privateAdd(this, _literal, void 0);
+  }
+  /**
+   * Returns the configuration object for the selected
+   * environment by weighting.
+   * 
+   * By priority the environment is selected by:
+   * 1. Literal
+   * 2. Environment Variable
+   * 3. Factory
+   */
+  get value() {
+    if (__privateGet(this, _literal)) {
+      return __privateGet(this, _literal);
+    }
+    if (__privateGet(this, _envVar)) {
+      const value = process.env[__privateGet(this, _envVar)];
+      if (value) {
+        return value;
+      }
+    }
+    if (__privateGet(this, _factory)) {
+      return __privateGet(this, _factory).call(this);
+    }
+  }
+  byEnvironmentVariable(envVar) {
+    __privateSet(this, _envVar, envVar);
+    return this;
+  }
+  byFactory(factory) {
+    __privateSet(this, _factory, factory);
+    return this;
+  }
+  byLiteral(literal) {
+    __privateSet(this, _literal, literal);
+    return this;
+  }
+};
+_envVar = new WeakMap();
+_factory = new WeakMap();
+_literal = new WeakMap();
+
+// src/config-object.ts
+var Config = class {
+  constructor(envMap) {
+    this.envMap = envMap;
+    this.environments = new EnvironmentReader();
+  }
+  get current() {
+    const key = this.environments.value;
+    if (!key) {
+      if (!this.envMap.has("default")) {
+        throw new import_errors.AutomationError(
+          `No environment is defined. Define an environment with 'env.byLiteral("my-environment")' or 'env.byEnvironmentVariable("MY_ENVIRONMENT")' or 'env.byFactory(() => "my-environment")' or 'env.byLiteral("default")'`
+        );
+      }
+      return this.envMap.get("default");
+    }
+    if (!this.envMap.has(key)) {
+      throw new import_errors.AutomationError(
+        `Environment ${key} is not defined. Options are: 
+ ${Object.keys(
+          this.envMap
+        ).join("\n")}`
+      );
+    }
+    return this.envMap.get(key) ?? (0, import_errors.raise)(`Environment ${key} is not defined`);
+  }
+};
+
+// src/define-config.ts
+var import_errors2 = require("@autometa/errors");
+function defineConfig(config, ...configs) {
+  const envs = [];
+  const envMap = config.envMap;
+  for (const config2 of configs) {
+    if (config2.environment) {
+      if (envs.includes(config2.environment)) {
+        throw new import_errors2.AutomationError(
+          `Environment ${config2.environment} is defined more than once`
+        );
+      }
+      envMap.set(config2.environment, config2);
+      envs.push(config2.environment);
+    } else if (!config2.environment && envs.includes("default")) {
+      throw new import_errors2.AutomationError(`Only one default environment can be defined`);
+    } else {
+      envMap.set("default", config2);
+      envs.push("default");
+      config2.environment = "default";
+    }
+  }
+  const setters = config.environments;
+  return {
+    env: setters
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  EnvironmentReader,
+  defineConfig
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@autometa/config",
+  "version": "0.0.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "import": "./dist/esm/index.js",
+    "require": "./dist/index.js",
+    "default": "./dist/esm/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^18.11.18",
+    "@types/uuid": "^9.0.1",
+    "@typescript-eslint/eslint-plugin": "^5.54.1",
+    "@typescript-eslint/parser": "^5.54.1",
+    "eslint": "^8.37.0",
+    "eslint-config-custom": "0.5.1",
+    "eslint-config-prettier": "^8.3.0",
+    "rimraf": "^4.1.2",
+    "tsconfig": " *",
+    "tsup": "^6.7.0",
+    "typescript": "^4.9.5",
+    "vitest": "^0.29.8"
+  },
+  "dependencies": {
+    "@autometa/app": "^0.0.0",
+    "@autometa/asserters": "^0.0.0",
+    "@autometa/errors": "^0.0.0",
+    "@autometa/types": "^0.3.1",
+    "zod": "^3.21.4"
+  },
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "prettify": "prettier --config .prettierrc 'src/**/*.ts' --write",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "clean": "rimraf dist",
+    "build": "tsup",
+    "build:watch": "tsup --watch"
+  },
+  "readme": "# Introduction\n\nThere's nothing here yet"
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  clean: true, // clean up the dist folder
+  format: ["cjs", "esm"], // generate cjs and esm files
+  dts: true,
+  sourcemap: false, // generate sourcemaps
+  skipNodeModulesBundle: true,
+  entryPoints: ["src/index.ts"],
+  target: "es2020",
+  outDir: "dist",
+  legacyOutput: true,
+  external: ["dist"],
+});