quiet-env-resolver 0.0.0-stage → 0.1.1

package/.editorconfig

@@ -0,0 +1,12 @@
+# ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+
+root=true
+
+[*]
+end_of_line=lf
+charset=utf-8
+
+[*\.{js,ts}]
+indent_style=space
+indent_size=2
+max_line_length=160

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,123 @@
-# Temporary Holding Version
+# Quiet Env Resolver
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/quiet-env-resolver?style=flat-square)](https://www.npmjs.com/package/quiet-env-resolver)
+[![license](https://img.shields.io/npm/l/quiet-env-resolver?style=flat-square)](https://www.npmjs.com/package/quiet-env-resolver)
+[![Node.js](https://img.shields.io/node/v/quiet-env-resolver?style=flat-square)](https://www.npmjs.com/package/quiet-env-resolver)
+[![build](https://img.shields.io/github/actions/workflow/status/gammarers-labs/quiet-env-resolver/build.yml?label=build&style=flat-square)](https://github.com/gammarers-labs/quiet-env-resolver/actions/workflows/build.yml)
+
+Resolves environment variables without throwing. Wraps `strict-env-resolver` and reports failures through an `onError` callback.
+
+## Features
+
+- Reads `string`, `number`, `boolean`, and `enum` environment variables with the same specs as `strict-env-resolver`
+- Reports a failure through an optional `onError` instead of throwing
+- Passes shape mismatches as `QuietEnvResolverValidateError` and leaves any other thrown value unchanged
+- Resolves one variable with `resolve`, or every key in a schema with `resolves`
+
+## How it works
+
+`resolve` and `resolves` call `strict-env-resolver`. That library throws when a variable is missing or invalid. This package catches the throw. A validation failure is passed to `onError` as `QuietEnvResolverValidateError`, without the rejected value. Any other thrown value is passed through unchanged. `onError` is optional: a callback, or `{ onError }` as the last argument. After a failure the call returns `undefined`. `default` is still the strict fallback for a missing value, and a missing value that uses `default` does not call `onError`.
+
+## Installation
+
+### npm
+
+```bash
+npm install quiet-env-resolver
+```
+
+### yarn
+
+```bash
+yarn add quiet-env-resolver
+```
+
+### pnpm
+
+```bash
+pnpm add quiet-env-resolver
+```
+
+## Usage
+
+```ts
+import { QuietEnvResolver, StrictEnvType } from 'quiet-env-resolver';
+
+const port = QuietEnvResolver.resolve('PORT', StrictEnvType.Number.Port, { default: 3000 });
+```
+
+`port` is `3000` when `PORT` is unset, the parsed number when `PORT` is valid, and `undefined` when parsing fails. No error is thrown.
+
+Pass `onError` as the last argument. A function and `{ onError }` are both accepted:
+
+```ts
+import { QuietEnvResolver, QuietEnvResolverValidateError, StrictEnvType } from 'quiet-env-resolver';
+
+const fromInvalid = QuietEnvResolver.resolve('PORT', StrictEnvType.Number.Port, (error) => {
+  console.error('failed to parse config', error);
+});
+
+const checked = QuietEnvResolver.resolve('PORT', StrictEnvType.Number.Port, { default: 3000 }, {
+  onError: (error) => {
+    if (error instanceof QuietEnvResolverValidateError) {
+      console.error('config shape mismatch');
+      return;
+    }
+    console.error('failed to parse config', error);
+  },
+});
+```
+
+Check `QuietEnvResolverValidateError` before `QuietEnvResolverError`. The validation error does not include the rejected value.
+
+Several variables in one call:
+
+```ts
+const envs = QuietEnvResolver.resolves({
+  PORT: [StrictEnvType.Number.Port, { default: 3000 }],
+  DEBUG: [StrictEnvType.Boolean, { default: false }],
+  MODE: StrictEnvType.Enum(['read', 'write'] as const),
+}, {
+  onError: (error) => {
+    if (error instanceof QuietEnvResolverValidateError) {
+      console.error('config shape mismatch');
+      return;
+    }
+    console.error('failed to parse config', error);
+  },
+});
+```
+
+## Options
+
+### `QuietEnvResolver.resolve(key, spec?, options?, onError?)`
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| **key** | Yes | Environment variable name (for example `"PORT"`). |
+| **spec** | No | Type spec. Defaults to `StrictEnvType.String`. Use `StrictEnvType.String`, `StrictEnvType.Number` (or a preset such as `Number.Port`), `StrictEnvType.Boolean`, or `StrictEnvType.Enum(choices)`. |
+| **options** | No | `{ default, trim }` forwarded to `strict-env-resolver`. `onError` may sit on this object. |
+| **onError** | No | Last argument. A callback `(error: unknown) => void`, or `{ onError }`. |
+
+### `QuietEnvResolver.resolves(schema, onError?)`
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| **schema** | Yes | Object whose keys are env names. Each value is a spec, or a `[spec, options]` tuple. |
+| **onError** | No | Last argument. A callback, or `{ onError }`. One failure is reported for the whole schema. |
+
+### `onError`
+
+| Field | Type | Description |
+|-------|------|-------------|
+| **onError** | `(error: unknown) => void` | Optional. Validation failures are `QuietEnvResolverValidateError`. Other thrown values are unchanged. Not called when `default` covers a missing value. |
+
+A successful call returns the parsed value and does not call `onError`. A failed call calls `onError` when it was passed, then returns `undefined`. An exception thrown by `onError` propagates to the caller. Omitting `onError` still returns `undefined` and does not throw.
+
+## Requirements
+
+- **Node.js** >= 20.0.0
+
+## License
+
+This project is licensed under the Apache-2.0 License.

package/lib/core/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Base error for quiet-env-resolver.
+ *
+ * Resolution failures are not thrown. Callers receive them through `onError`.
+ * Check {@link QuietEnvResolverValidateError} before this base class.
+ *
+ * @example
+ * ```ts
+ * if (error instanceof QuietEnvResolverValidateError) {
+ *   return;
+ * }
+ * if (error instanceof QuietEnvResolverError) {
+ *   // Other errors raised by this package.
+ * }
+ * ```
+ */
+export declare abstract class QuietEnvResolverError extends Error {
+    readonly name: string;
+    /**
+     * @param message - Error message.
+     */
+    protected constructor(message: string);
+}
+/**
+ * Passed to `onError` when `strict-env-resolver` rejects a value.
+ *
+ * The rejected value is omitted so logs do not include raw environment data.
+ */
+export declare class QuietEnvResolverValidateError extends QuietEnvResolverError {
+    readonly name: string;
+    /**
+     * @param message - Override for the default shape-mismatch message.
+     */
+    constructor(message?: string);
+}

package/lib/core/errors.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuietEnvResolverValidateError = exports.QuietEnvResolverError = void 0;
+/**
+ * Base error for quiet-env-resolver.
+ *
+ * Resolution failures are not thrown. Callers receive them through `onError`.
+ * Check {@link QuietEnvResolverValidateError} before this base class.
+ *
+ * @example
+ * ```ts
+ * if (error instanceof QuietEnvResolverValidateError) {
+ *   return;
+ * }
+ * if (error instanceof QuietEnvResolverError) {
+ *   // Other errors raised by this package.
+ * }
+ * ```
+ */
+class QuietEnvResolverError extends Error {
+    /**
+     * @param message - Error message.
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'QuietEnvResolverError';
+        Object.setPrototypeOf(this, QuietEnvResolverError.prototype);
+    }
+}
+exports.QuietEnvResolverError = QuietEnvResolverError;
+const VALIDATE_MISMATCH_MESSAGE = 'Environment variable did not match the expected shape';
+/**
+ * Passed to `onError` when `strict-env-resolver` rejects a value.
+ *
+ * The rejected value is omitted so logs do not include raw environment data.
+ */
+class QuietEnvResolverValidateError extends QuietEnvResolverError {
+    /**
+     * @param message - Override for the default shape-mismatch message.
+     */
+    constructor(message = VALIDATE_MISMATCH_MESSAGE) {
+        super(message);
+        this.name = 'QuietEnvResolverValidateError';
+        Object.setPrototypeOf(this, QuietEnvResolverValidateError.prototype);
+    }
+}
+exports.QuietEnvResolverValidateError = QuietEnvResolverValidateError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvcmUvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUNILE1BQXNCLHFCQUFzQixTQUFRLEtBQUs7SUFHdkQ7O09BRUc7SUFDSCxZQUFzQixPQUFlO1FBQ25DLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQU5DLFNBQUksR0FBVyx1QkFBdUIsQ0FBQztRQU92RCxNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSxxQkFBcUIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUMvRCxDQUFDO0NBQ0Y7QUFWRCxzREFVQztBQUVELE1BQU0seUJBQXlCLEdBQUcsdURBQXVELENBQUM7QUFFMUY7Ozs7R0FJRztBQUNILE1BQWEsNkJBQThCLFNBQVEscUJBQXFCO0lBR3RFOztPQUVHO0lBQ0gsWUFBWSxVQUFrQix5QkFBeUI7UUFDckQsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBTkMsU0FBSSxHQUFXLCtCQUErQixDQUFDO1FBTy9ELE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLDZCQUE2QixDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3ZFLENBQUM7Q0FDRjtBQVZELHNFQVVDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBCYXNlIGVycm9yIGZvciBxdWlldC1lbnYtcmVzb2x2ZXIuXG4gKlxuICogUmVzb2x1dGlvbiBmYWlsdXJlcyBhcmUgbm90IHRocm93bi4gQ2FsbGVycyByZWNlaXZlIHRoZW0gdGhyb3VnaCBgb25FcnJvcmAuXG4gKiBDaGVjayB7QGxpbmsgUXVpZXRFbnZSZXNvbHZlclZhbGlkYXRlRXJyb3J9IGJlZm9yZSB0aGlzIGJhc2UgY2xhc3MuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiBpZiAoZXJyb3IgaW5zdGFuY2VvZiBRdWlldEVudlJlc29sdmVyVmFsaWRhdGVFcnJvcikge1xuICogICByZXR1cm47XG4gKiB9XG4gKiBpZiAoZXJyb3IgaW5zdGFuY2VvZiBRdWlldEVudlJlc29sdmVyRXJyb3IpIHtcbiAqICAgLy8gT3RoZXIgZXJyb3JzIHJhaXNlZCBieSB0aGlzIHBhY2thZ2UuXG4gKiB9XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFF1aWV0RW52UmVzb2x2ZXJFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgb3ZlcnJpZGUgcmVhZG9ubHkgbmFtZTogc3RyaW5nID0gJ1F1aWV0RW52UmVzb2x2ZXJFcnJvcic7XG5cbiAgLyoqXG4gICAqIEBwYXJhbSBtZXNzYWdlIC0gRXJyb3IgbWVzc2FnZS5cbiAgICovXG4gIHByb3RlY3RlZCBjb25zdHJ1Y3RvcihtZXNzYWdlOiBzdHJpbmcpIHtcbiAgICBzdXBlcihtZXNzYWdlKTtcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2YodGhpcywgUXVpZXRFbnZSZXNvbHZlckVycm9yLnByb3RvdHlwZSk7XG4gIH1cbn1cblxuY29uc3QgVkFMSURBVEVfTUlTTUFUQ0hfTUVTU0FHRSA9ICdFbnZpcm9ubWVudCB2YXJpYWJsZSBkaWQgbm90IG1hdGNoIHRoZSBleHBlY3RlZCBzaGFwZSc7XG5cbi8qKlxuICogUGFzc2VkIHRvIGBvbkVycm9yYCB3aGVuIGBzdHJpY3QtZW52LXJlc29sdmVyYCByZWplY3RzIGEgdmFsdWUuXG4gKlxuICogVGhlIHJlamVjdGVkIHZhbHVlIGlzIG9taXR0ZWQgc28gbG9ncyBkbyBub3QgaW5jbHVkZSByYXcgZW52aXJvbm1lbnQgZGF0YS5cbiAqL1xuZXhwb3J0IGNsYXNzIFF1aWV0RW52UmVzb2x2ZXJWYWxpZGF0ZUVycm9yIGV4dGVuZHMgUXVpZXRFbnZSZXNvbHZlckVycm9yIHtcbiAgb3ZlcnJpZGUgcmVhZG9ubHkgbmFtZTogc3RyaW5nID0gJ1F1aWV0RW52UmVzb2x2ZXJWYWxpZGF0ZUVycm9yJztcblxuICAvKipcbiAgICogQHBhcmFtIG1lc3NhZ2UgLSBPdmVycmlkZSBmb3IgdGhlIGRlZmF1bHQgc2hhcGUtbWlzbWF0Y2ggbWVzc2FnZS5cbiAgICovXG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZyA9IFZBTElEQVRFX01JU01BVENIX01FU1NBR0UpIHtcbiAgICBzdXBlcihtZXNzYWdlKTtcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2YodGhpcywgUXVpZXRFbnZSZXNvbHZlclZhbGlkYXRlRXJyb3IucHJvdG90eXBlKTtcbiAgfVxufVxuIl19

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Public entry for quiet-env-resolver.
+ * Re-exports the quiet resolver, package errors, and the spec types callers need.
+ * Implementation lives in the resolver module and in core.
+ */
+export { QuietEnvResolver } from './resolver';
+export type { QuietEnvHandler, QuietEnvOnError, QuietEnvOptions } from './resolver';
+export { QuietEnvResolverError, QuietEnvResolverValidateError } from './core/errors';
+export { StrictEnvType } from 'strict-env-resolver';
+export type { StrictEnvNumberConstraints, StrictEnvOptions, StrictEnvSchema, StrictEnvSchemaEntry, StrictEnvSchemaToType, StrictEnvSpec, StrictEnvSpecToType, StrictEnvTypeBoolean, StrictEnvTypeEnum, StrictEnvTypeNumber, StrictEnvTypeString, } from 'strict-env-resolver';

package/lib/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrictEnvType = exports.QuietEnvResolverValidateError = exports.QuietEnvResolverError = exports.QuietEnvResolver = void 0;
+/**
+ * Public entry for quiet-env-resolver.
+ * Re-exports the quiet resolver, package errors, and the spec types callers need.
+ * Implementation lives in the resolver module and in core.
+ */
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "QuietEnvResolver", { enumerable: true, get: function () { return resolver_1.QuietEnvResolver; } });
+var errors_1 = require("./core/errors");
+Object.defineProperty(exports, "QuietEnvResolverError", { enumerable: true, get: function () { return errors_1.QuietEnvResolverError; } });
+Object.defineProperty(exports, "QuietEnvResolverValidateError", { enumerable: true, get: function () { return errors_1.QuietEnvResolverValidateError; } });
+var strict_env_resolver_1 = require("strict-env-resolver");
+Object.defineProperty(exports, "StrictEnvType", { enumerable: true, get: function () { return strict_env_resolver_1.StrictEnvType; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7R0FJRztBQUNILHVDQUE4QztBQUFyQyw0R0FBQSxnQkFBZ0IsT0FBQTtBQUl6Qix3Q0FBcUY7QUFBNUUsK0dBQUEscUJBQXFCLE9BQUE7QUFBRSx1SEFBQSw2QkFBNkIsT0FBQTtBQUU3RCwyREFBb0Q7QUFBM0Msb0hBQUEsYUFBYSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQdWJsaWMgZW50cnkgZm9yIHF1aWV0LWVudi1yZXNvbHZlci5cbiAqIFJlLWV4cG9ydHMgdGhlIHF1aWV0IHJlc29sdmVyLCBwYWNrYWdlIGVycm9ycywgYW5kIHRoZSBzcGVjIHR5cGVzIGNhbGxlcnMgbmVlZC5cbiAqIEltcGxlbWVudGF0aW9uIGxpdmVzIGluIHRoZSByZXNvbHZlciBtb2R1bGUgYW5kIGluIGNvcmUuXG4gKi9cbmV4cG9ydCB7IFF1aWV0RW52UmVzb2x2ZXIgfSBmcm9tICcuL3Jlc29sdmVyJztcblxuZXhwb3J0IHR5cGUgeyBRdWlldEVudkhhbmRsZXIsIFF1aWV0RW52T25FcnJvciwgUXVpZXRFbnZPcHRpb25zIH0gZnJvbSAnLi9yZXNvbHZlcic7XG5cbmV4cG9ydCB7IFF1aWV0RW52UmVzb2x2ZXJFcnJvciwgUXVpZXRFbnZSZXNvbHZlclZhbGlkYXRlRXJyb3IgfSBmcm9tICcuL2NvcmUvZXJyb3JzJztcblxuZXhwb3J0IHsgU3RyaWN0RW52VHlwZSB9IGZyb20gJ3N0cmljdC1lbnYtcmVzb2x2ZXInO1xuXG5leHBvcnQgdHlwZSB7XG4gIFN0cmljdEVudk51bWJlckNvbnN0cmFpbnRzLFxuICBTdHJpY3RFbnZPcHRpb25zLFxuICBTdHJpY3RFbnZTY2hlbWEsXG4gIFN0cmljdEVudlNjaGVtYUVudHJ5LFxuICBTdHJpY3RFbnZTY2hlbWFUb1R5cGUsXG4gIFN0cmljdEVudlNwZWMsXG4gIFN0cmljdEVudlNwZWNUb1R5cGUsXG4gIFN0cmljdEVudlR5cGVCb29sZWFuLFxuICBTdHJpY3RFbnZUeXBlRW51bSxcbiAgU3RyaWN0RW52VHlwZU51bWJlcixcbiAgU3RyaWN0RW52VHlwZVN0cmluZyxcbn0gZnJvbSAnc3RyaWN0LWVudi1yZXNvbHZlcic7XG4iXX0=

package/lib/resolver.d.ts

@@ -0,0 +1,52 @@
+import { type StrictEnvOptions, type StrictEnvSchema, type StrictEnvSchemaToType, type StrictEnvSpec, type StrictEnvSpecToType } from 'strict-env-resolver';
+/**
+ * Called when resolution fails.
+ *
+ * A shape mismatch is a {@link QuietEnvResolverValidateError}. Any other thrown
+ * value is passed through. Omitted callbacks are not invoked.
+ */
+export type QuietEnvOnError = (error: unknown) => void;
+/**
+ * Last-argument object form, matching `onError` inside quiet-json-parser options.
+ */
+export type QuietEnvHandler = {
+    /** Receives the failure. The resolver does not throw. */
+    readonly onError: QuietEnvOnError;
+};
+/**
+ * `strict-env-resolver` options, plus an optional `onError` on the same object.
+ *
+ * @typeParam S - Environment variable spec.
+ */
+export type QuietEnvOptions<S extends StrictEnvSpec = StrictEnvSpec> = StrictEnvOptions<S> & {
+    /** Called when this read fails. Same callback as the trailing `onError` argument. */
+    readonly onError?: QuietEnvOnError;
+};
+type QuietResolve = {
+    <K extends string>(key: K, onError?: QuietEnvOnError | QuietEnvHandler): string | undefined;
+    <K extends string, S extends StrictEnvSpec>(key: K, spec: S, onError?: QuietEnvOnError | QuietEnvHandler): StrictEnvSpecToType<S> | undefined;
+    <K extends string, S extends StrictEnvSpec>(key: K, spec: S, options: QuietEnvOptions<S>, onError?: QuietEnvOnError | QuietEnvHandler): StrictEnvSpecToType<S> | undefined;
+};
+/**
+ * Quiet wrapper around `strict-env-resolver`.
+ *
+ * @example
+ * ```ts
+ * const port = QuietEnvResolver.resolve('PORT', StrictEnvType.Number.Port, { default: 3000 }, {
+ *   onError: (error) => {
+ *     if (error instanceof QuietEnvResolverValidateError) {
+ *       console.error('config shape mismatch');
+ *       return;
+ *     }
+ *     console.error('failed to parse config', error);
+ *   },
+ * });
+ * ```
+ */
+export declare const QuietEnvResolver: {
+    /** Reads and parses a single environment variable. See {@link resolve}. */
+    resolve: QuietResolve;
+    /** Reads and parses every variable in a schema. See {@link resolves}. */
+    resolves: <TSchema extends StrictEnvSchema>(schema: TSchema, onErrorOrHandler?: QuietEnvOnError | QuietEnvHandler) => StrictEnvSchemaToType<TSchema> | undefined;
+};
+export {};

package/lib/resolver.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuietEnvResolver = void 0;
+const strict_env_resolver_1 = require("strict-env-resolver");
+const errors_1 = require("./core/errors");
+/**
+ * True for a trailing callback.
+ * `StrictEnvType.Number` is callable and also has `type`, so it stays a spec.
+ *
+ * @param value - Candidate argument.
+ * @returns Whether `value` is an `onError` callback.
+ */
+const isOnError = (value) => {
+    if (typeof value !== 'function') {
+        return false;
+    }
+    if ('type' in value) {
+        return false;
+    }
+    return true;
+};
+/**
+ * True for `{ onError }` when that object is not a spec or a `{ default, trim }` bag.
+ *
+ * @param value - Candidate argument.
+ * @returns Whether `value` is a handler object.
+ */
+const isOnErrorHandler = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (!('onError' in value) || typeof value.onError !== 'function') {
+        return false;
+    }
+    if ('type' in value || 'default' in value || 'trim' in value) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Reads `onError` from a callback, a handler object, or options that include it.
+ *
+ * @param value - Trailing argument or options bag.
+ * @returns The callback, or `undefined` when the caller did not pass one.
+ */
+const onErrorFrom = (value) => {
+    if (isOnError(value)) {
+        return value;
+    }
+    if (typeof value !== 'object' || value === null) {
+        return undefined;
+    }
+    if (!('onError' in value)) {
+        return undefined;
+    }
+    // `in` does not narrow the property to a callback.
+    const callback = value.onError;
+    if (!isOnError(callback)) {
+        return undefined;
+    }
+    return callback;
+};
+/**
+ * Maps a thrown validation error onto this package's error.
+ * Other thrown values stay as they are.
+ *
+ * @param error - Caught exception.
+ * @returns Value passed to `onError`.
+ */
+const toQuietError = (error) => {
+    if (!(error instanceof strict_env_resolver_1.StrictEnvValidationError)) {
+        return error;
+    }
+    return new errors_1.QuietEnvResolverValidateError();
+};
+/**
+ * Runs a strict read. Failures go to `onError` and become `undefined`.
+ * `onError` is outside the assignment so a handler failure is not caught again.
+ *
+ * @param read - Strict resolver call.
+ * @param onError - Optional failure callback.
+ * @returns Parsed value, or `undefined` after a failure.
+ */
+const reportQuietly = (read, onError) => {
+    let value;
+    try {
+        value = read();
+    }
+    catch (error) {
+        onError?.(toQuietError(error));
+        return undefined;
+    }
+    return value;
+};
+/**
+ * `strict-env-resolver` reads `default` and `trim` only. A sibling `onError` is ignored there.
+ *
+ * @param value - Caller options, which may also carry `onError`.
+ * @returns Options safe to forward.
+ */
+const asStrictOptions = (value) => value;
+const readOne = (key, spec, options, onError) => {
+    if (spec === undefined) {
+        return reportQuietly(() => strict_env_resolver_1.StrictEnvResolver.resolve(key), onError);
+    }
+    if (options === undefined) {
+        return reportQuietly(() => strict_env_resolver_1.StrictEnvResolver.resolve(key, spec), onError);
+    }
+    return reportQuietly(() => strict_env_resolver_1.StrictEnvResolver.resolve(key, spec, asStrictOptions(options)), onError);
+};
+/**
+ * Reads one environment variable.
+ *
+ * The last argument is optional. It may be an `onError` callback or `{ onError }`.
+ * `onError` may also sit on the options object next to `default` and `trim`.
+ * Validation failures become {@link QuietEnvResolverValidateError}. Other thrown
+ * values are passed through. Nothing is thrown when `onError` is omitted.
+ *
+ * Overload signatures are what callers see. The implementation narrows each
+ * argument shape at runtime because an arrow function cannot declare overloads.
+ *
+ * @param key - Environment variable name.
+ * @param spec - Type spec. Defaults to string when omitted.
+ * @param options - Optional `{ default, trim, onError }`.
+ * @param onError - Callback or `{ onError }`, used when it is not already on `options`.
+ * @returns Parsed value, or `undefined` when resolution fails.
+ */
+const resolve = ((key, second, third, fourth) => {
+    if (second === undefined) {
+        return readOne(key, undefined, undefined, undefined);
+    }
+    if (isOnError(second) || isOnErrorHandler(second)) {
+        return readOne(key, undefined, undefined, onErrorFrom(second));
+    }
+    if (third === undefined) {
+        return readOne(key, second, undefined, undefined);
+    }
+    if (isOnError(third) || isOnErrorHandler(third)) {
+        return readOne(key, second, undefined, onErrorFrom(third));
+    }
+    // Fourth argument wins when both the options bag and the last argument set onError.
+    return readOne(key, second, third, onErrorFrom(fourth) ?? onErrorFrom(third));
+});
+/**
+ * Reads every variable in `schema`.
+ *
+ * One validation failure is reported once. `onError` is optional and may be a
+ * callback or `{ onError }`.
+ *
+ * @param schema - Map of env names to specs or `[spec, options]` tuples.
+ * @param onErrorOrHandler - Optional callback or `{ onError }`.
+ * @returns Parsed object, or `undefined` when resolution fails.
+ */
+const resolves = (schema, onErrorOrHandler) => reportQuietly(() => strict_env_resolver_1.StrictEnvResolver.resolves(schema), onErrorFrom(onErrorOrHandler));
+/**
+ * Quiet wrapper around `strict-env-resolver`.
+ *
+ * @example
+ * ```ts
+ * const port = QuietEnvResolver.resolve('PORT', StrictEnvType.Number.Port, { default: 3000 }, {
+ *   onError: (error) => {
+ *     if (error instanceof QuietEnvResolverValidateError) {
+ *       console.error('config shape mismatch');
+ *       return;
+ *     }
+ *     console.error('failed to parse config', error);
+ *   },
+ * });
+ * ```
+ */
+exports.QuietEnvResolver = {
+    /** Reads and parses a single environment variable. See {@link resolve}. */
+    resolve,
+    /** Reads and parses every variable in a schema. See {@link resolves}. */
+    resolves,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  StrictEnvResolver,\n  StrictEnvValidationError,\n  type StrictEnvOptions,\n  type StrictEnvSchema,\n  type StrictEnvSchemaToType,\n  type StrictEnvSpec,\n  type StrictEnvSpecToType,\n} from 'strict-env-resolver';\nimport { QuietEnvResolverValidateError } from './core/errors';\n\n/**\n * Called when resolution fails.\n *\n * A shape mismatch is a {@link QuietEnvResolverValidateError}. Any other thrown\n * value is passed through. Omitted callbacks are not invoked.\n */\nexport type QuietEnvOnError = (error: unknown) => void;\n\n/**\n * Last-argument object form, matching `onError` inside quiet-json-parser options.\n */\nexport type QuietEnvHandler = {\n  /** Receives the failure. The resolver does not throw. */\n  readonly onError: QuietEnvOnError;\n};\n\n/**\n * `strict-env-resolver` options, plus an optional `onError` on the same object.\n *\n * @typeParam S - Environment variable spec.\n */\nexport type QuietEnvOptions<S extends StrictEnvSpec = StrictEnvSpec> = StrictEnvOptions<S> & {\n  /** Called when this read fails. Same callback as the trailing `onError` argument. */\n  readonly onError?: QuietEnvOnError;\n};\n\n/**\n * True for a trailing callback.\n * `StrictEnvType.Number` is callable and also has `type`, so it stays a spec.\n *\n * @param value - Candidate argument.\n * @returns Whether `value` is an `onError` callback.\n */\nconst isOnError = (value: unknown): value is QuietEnvOnError => {\n  if (typeof value !== 'function') {\n    return false;\n  }\n\n  if ('type' in value) {\n    return false;\n  }\n\n  return true;\n};\n\n/**\n * True for `{ onError }` when that object is not a spec or a `{ default, trim }` bag.\n *\n * @param value - Candidate argument.\n * @returns Whether `value` is a handler object.\n */\nconst isOnErrorHandler = (value: unknown): value is QuietEnvHandler => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  if (!('onError' in value) || typeof value.onError !== 'function') {\n    return false;\n  }\n\n  if ('type' in value || 'default' in value || 'trim' in value) {\n    return false;\n  }\n\n  return true;\n};\n\n/**\n * Reads `onError` from a callback, a handler object, or options that include it.\n *\n * @param value - Trailing argument or options bag.\n * @returns The callback, or `undefined` when the caller did not pass one.\n */\nconst onErrorFrom = (value: unknown): QuietEnvOnError | undefined => {\n  if (isOnError(value)) {\n    return value;\n  }\n\n  if (typeof value !== 'object' || value === null) {\n    return undefined;\n  }\n\n  if (!('onError' in value)) {\n    return undefined;\n  }\n\n  // `in` does not narrow the property to a callback.\n  const callback: unknown = value.onError;\n  if (!isOnError(callback)) {\n    return undefined;\n  }\n\n  return callback;\n};\n\n/**\n * Maps a thrown validation error onto this package's error.\n * Other thrown values stay as they are.\n *\n * @param error - Caught exception.\n * @returns Value passed to `onError`.\n */\nconst toQuietError = (error: unknown): unknown => {\n  if (!(error instanceof StrictEnvValidationError)) {\n    return error;\n  }\n\n  return new QuietEnvResolverValidateError();\n};\n\n/**\n * Runs a strict read. Failures go to `onError` and become `undefined`.\n * `onError` is outside the assignment so a handler failure is not caught again.\n *\n * @param read - Strict resolver call.\n * @param onError - Optional failure callback.\n * @returns Parsed value, or `undefined` after a failure.\n */\nconst reportQuietly = <T>(read: () => T, onError?: QuietEnvOnError): T | undefined => {\n  let value: T;\n\n  try {\n    value = read();\n  } catch (error) {\n    onError?.(toQuietError(error));\n    return undefined;\n  }\n\n  return value;\n};\n\n/**\n * `strict-env-resolver` reads `default` and `trim` only. A sibling `onError` is ignored there.\n *\n * @param value - Caller options, which may also carry `onError`.\n * @returns Options safe to forward.\n */\nconst asStrictOptions = (value: object): StrictEnvOptions<StrictEnvSpec> => (\n  value as StrictEnvOptions<StrictEnvSpec>\n);\n\nconst readOne = (\n  key: string,\n  spec: StrictEnvSpec | undefined,\n  options: object | undefined,\n  onError: QuietEnvOnError | undefined,\n): string | number | boolean | undefined => {\n  if (spec === undefined) {\n    return reportQuietly(() => StrictEnvResolver.resolve(key), onError);\n  }\n\n  if (options === undefined) {\n    return reportQuietly(() => StrictEnvResolver.resolve(key, spec), onError);\n  }\n\n  return reportQuietly(\n    () => StrictEnvResolver.resolve(key, spec, asStrictOptions(options)),\n    onError,\n  );\n};\n\ntype QuietResolve = {\n  <K extends string>(key: K, onError?: QuietEnvOnError | QuietEnvHandler): string | undefined;\n  <K extends string, S extends StrictEnvSpec>(\n    key: K,\n    spec: S,\n    onError?: QuietEnvOnError | QuietEnvHandler,\n  ): StrictEnvSpecToType<S> | undefined;\n  <K extends string, S extends StrictEnvSpec>(\n    key: K,\n    spec: S,\n    options: QuietEnvOptions<S>,\n    onError?: QuietEnvOnError | QuietEnvHandler,\n  ): StrictEnvSpecToType<S> | undefined;\n};\n\n/**\n * Reads one environment variable.\n *\n * The last argument is optional. It may be an `onError` callback or `{ onError }`.\n * `onError` may also sit on the options object next to `default` and `trim`.\n * Validation failures become {@link QuietEnvResolverValidateError}. Other thrown\n * values are passed through. Nothing is thrown when `onError` is omitted.\n *\n * Overload signatures are what callers see. The implementation narrows each\n * argument shape at runtime because an arrow function cannot declare overloads.\n *\n * @param key - Environment variable name.\n * @param spec - Type spec. Defaults to string when omitted.\n * @param options - Optional `{ default, trim, onError }`.\n * @param onError - Callback or `{ onError }`, used when it is not already on `options`.\n * @returns Parsed value, or `undefined` when resolution fails.\n */\nconst resolve = ((\n  key: string,\n  second?: StrictEnvSpec | QuietEnvOnError | QuietEnvHandler,\n  third?: QuietEnvOptions<StrictEnvSpec> | QuietEnvOnError | QuietEnvHandler,\n  fourth?: QuietEnvOnError | QuietEnvHandler,\n): string | number | boolean | undefined => {\n  if (second === undefined) {\n    return readOne(key, undefined, undefined, undefined);\n  }\n\n  if (isOnError(second) || isOnErrorHandler(second)) {\n    return readOne(key, undefined, undefined, onErrorFrom(second));\n  }\n\n  if (third === undefined) {\n    return readOne(key, second, undefined, undefined);\n  }\n\n  if (isOnError(third) || isOnErrorHandler(third)) {\n    return readOne(key, second, undefined, onErrorFrom(third));\n  }\n\n  // Fourth argument wins when both the options bag and the last argument set onError.\n  return readOne(key, second, third, onErrorFrom(fourth) ?? onErrorFrom(third));\n}) as QuietResolve;\n\n/**\n * Reads every variable in `schema`.\n *\n * One validation failure is reported once. `onError` is optional and may be a\n * callback or `{ onError }`.\n *\n * @param schema - Map of env names to specs or `[spec, options]` tuples.\n * @param onErrorOrHandler - Optional callback or `{ onError }`.\n * @returns Parsed object, or `undefined` when resolution fails.\n */\nconst resolves = <TSchema extends StrictEnvSchema>(\n  schema: TSchema,\n  onErrorOrHandler?: QuietEnvOnError | QuietEnvHandler,\n): StrictEnvSchemaToType<TSchema> | undefined => reportQuietly(\n  () => StrictEnvResolver.resolves(schema),\n  onErrorFrom(onErrorOrHandler),\n);\n\n/**\n * Quiet wrapper around `strict-env-resolver`.\n *\n * @example\n * ```ts\n * const port = QuietEnvResolver.resolve('PORT', StrictEnvType.Number.Port, { default: 3000 }, {\n *   onError: (error) => {\n *     if (error instanceof QuietEnvResolverValidateError) {\n *       console.error('config shape mismatch');\n *       return;\n *     }\n *     console.error('failed to parse config', error);\n *   },\n * });\n * ```\n */\nexport const QuietEnvResolver = {\n  /** Reads and parses a single environment variable. See {@link resolve}. */\n  resolve,\n  /** Reads and parses every variable in a schema. See {@link resolves}. */\n  resolves,\n};\n"]}

package/package.json

@@ -1,6 +1,123 @@
 {
   "name": "quiet-env-resolver",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "A library for resolving environment variables in a quiet way.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gammarers-labs/quiet-env-resolver.git"
+  },
+  "scripts": {
+    "build": "projen build",
+    "bump": "projen bump",
+    "bump:releasable-commits": "projen bump:releasable-commits",
+    "clobber": "projen clobber",
+    "compile": "projen compile",
+    "default": "projen default",
+    "eject": "projen eject",
+    "eslint": "projen eslint",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "post-upgrade": "projen post-upgrade",
+    "pre-compile": "projen pre-compile",
+    "release": "projen release",
+    "test": "projen test",
+    "test:watch": "projen test:watch",
+    "unbump": "projen unbump",
+    "upgrade": "projen upgrade",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "author": {
+    "name": "yicr",
+    "email": "yicr@users.noreply.github.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@gammarers/projen-projects": "^0.5.8",
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "commit-and-tag-version": "^13",
+    "constructs": "^10.0.0",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.5.2",
+    "jest-junit": "^17",
+    "projen": "^0.104.5",
+    "ts-jest": "^29.4.14",
+    "ts-node": "^10.9.2",
+    "typescript": "6.0.x"
+  },
+  "dependencies": {
+    "strict-env-resolver": "^0.8.0"
+  },
+  "keywords": [
+    "environment",
+    "resolver",
+    "variables"
+  ],
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "npm",
+      "onFail": "ignore"
+    }
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.1.1",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "test/tsconfig.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}