@romaintaillandier1978/dotenv-never-lies 1.5.0 → 1.8.0

package/README.md

@@ -8,7 +8,9 @@
 **dotenv-never-lies** validates, types, and documents your environment variables from a TypeScript / Zod schema.  
 It fails fast, loud, and before production.
 
-## Why?
+## Introduction#
+
+### Why?
 
 ecause all of this happens all the time:
 
@@ -29,7 +31,7 @@ And because `.env` files are:
 
 ---
 
-## What the library does
+### What the library does
 
 - ✅ validates environment variables at startup  
   powered by Zod, enabling complex transformations (arrays, parsing, coercion…)
@@ -41,7 +43,7 @@ And because `.env` files are:
 
 ---
 
-## What dotenv-never-lies is not
+### What dotenv-never-lies is not
 
 This package has a deliberately limited scope.
 
@@ -71,7 +73,7 @@ that prefer to **fail cleanly at startup** rather than **silently break in produ
 
 ---
 
-## Installation
+### Installation
 
 ```bash
 npm install @romaintaillandier1978/dotenv-never-lies
@@ -79,7 +81,7 @@ npm install @romaintaillandier1978/dotenv-never-lies
 yarn add @romaintaillandier1978/dotenv-never-lies
 ```
 
-## Dependencies and compatibility
+### Dependencies and compatibility
 
 **[`zod`](https://www.npmjs.com/package/zod)** — dotenv-never-lies exposes Zod schemas in its public API.
 
@@ -127,6 +129,12 @@ Supported in this order for all CLI commands:
 
 3. one of `env.dnl.ts`, `env.dnl.js`, `dnl.config.ts`, `dnl.config.js`
 
+4. as you wish, using the `--schema` option
+
+```bash
+dnl infer --schema path/to/my-dnl.ts
+```
+
 ### define a schema
 
 ```typescript
@@ -157,11 +165,11 @@ export default define({
 });
 ```
 
-## Secrets handling
+### Secrets handling
 
 Reminder: dotenv-never-lies is not a secrets manager.
 
-### declaration in the DNL schema
+**declaration in the DNL schema**
 
 A variable is considered secret if and only if it is explicitly marked in the schema with `secret: true`.  
 (`secret: undefined` is equivalent to `secret: false`)  
@@ -199,6 +207,8 @@ This separation ensures that validation, runtime usage and configuration export
 
 ## Runtime usage
 
+### assert: validate variables at runtime
+
 ```typescript
 import envDef from "./env.dnl";
 
@@ -226,10 +236,9 @@ Result:
 If a variable is missing or invalid → the process exits immediately.  
 This is intentional.
 
-## Avoid `process.env` in application code
+### Avoid `process.env` in application code
 
-Once the schema is loaded, environment variables  
-must be accessed exclusively via the `ENV` object.
+Once the schema is loaded, environment variables must be accessed exclusively via the `ENV` object.
 
 This guarantees:
 
@@ -237,17 +246,13 @@ This guarantees:
 - validated values
 - a single entry point for configuration
 
-To identify residual `process.env` usages in your codebase, a simple search tool is enough:
-
-```bash
-grep -R "process\.env" src
-```
+To identify residual `process.env` usages in your codebase, use the `dnl annotate` [annotate command](docs/commands/annotate.md) for more details.
 
 Choosing to refactor (or not) those usages depends on context and is intentionally left to the developer.
 
 ## CLI
 
-The CLI lets you validate, load, generate, export, and document environment variables from a `dotenv-never-lies` schema.
+The CLI lets you infer, types, assert, export, and explain environment variables to/from a `dotenv-never-lies` schema.
 
 It is designed to be used:
 
@@ -267,17 +272,58 @@ It is designed to be used:
 |    3 | Environment validation failed |
 |    4 | Error during export           |
 
-### assert: Validate a `.env` file (CI-friendly)
+### infer: discover a .envfile, and generate a schema from an existing .env
+
+Generate a DNL schema from an existing `.env` file.
+
+```bash
+dnl infer --source .env
+```
+
+Useful for migrating an existing project
+
+→ [Read infer documentation](docs/commands/infer.md)
+
+### types: generate a TypeScript declaration file from an existing DNL schema
+
+Generates a `./src/types/env.dnl.d.ts` file from the `env.dnl.ts` file.
+
+```bash
+dnl types
+```
+
+Useful for getting IntelliSense _after_ finalizing your DNL schema completion.
+
+→ [Read infer documentation](docs/commands/types.md)
+
+### annotate: Identify and manage `process.env` usages
+
+Scans the codebase and adds contextual annotations to help migrate from `process.env` to DNL-validated variables.
+
+```bash
+dnl annotate
+```
+
+- Use locally to discover and progressively replace legacy `process.env` usages.
+- Use `dnl annotate --check` in CI or Git hooks (pre-commit, post-merge) to prevent introducing new unreviewed `process.env` accesses.
+
+→ [Read annotate documentation](docs/commands/annotate.md)
+
+### assert: Validate environement variables (runtime, CI-friendly)
 
 Validates variables without injecting them into `process.env`.
 
 ```bash
-dnl assert --source .env --schema env.dnl.ts
+dnl assert --source .env
 ```
 
 Without `--source`, `dnl assert` validates `process.env`.  
 This is the recommended mode when variables are injected by the runtime or CI.
 
+```bash
+dnl assert
+```
+
 → fails if:
 
 - a variable is missing
@@ -290,7 +336,7 @@ Initialize a documented `.env` from the schema.
 Do not read any environment variables
 
 ```bash
-dnl init --schema env.dnl.ts --out .env
+dnl init --out .env
 ```
 
 Useful for:
@@ -299,18 +345,6 @@ Useful for:
 - sharing a template
 - avoiding obsolete `.env.example` files
 
-### infer: discover a .envfile, and generate a schema from an existing .env
-
-Generate a DNL schema from an existing `.env` file.
-
-```bash
-dnl infer --source .env
-```
-
-Useful for migrating an existing project
-
-→ [Read infer documentation](docs/commands/infer.md)
-
 ### explain: Display variables documentation
 
 Displays the list of known variables and their description.
@@ -334,73 +368,25 @@ The `export` command transforms variables validated by the schema
 into formats directly consumable by other tools (Docker, CI, Kubernetes, scripts…).
 
 The schema remains the source of truth.  
-Values are validated before export.
-
-```bash
-dnl export <format>
-```
+Values are validated before export, and validated AND raw values are passed to the exporter.
 
-By default, values are read from `process.env`.  
-A `.env` file can be provided via `--source`.
-
-Examples:  
-Export environment variables as JSON from a `.env` file
-
-```bash
-dnl export json --source .env
-```
-
-Clean a `.env` file (remove comments and extraneous lines)
+Example:
 
 ```bash
-dnl export env --source .env --out .env.clean
-dnl export env --source .env --out .env --force
+dnl export docker-args
 ```
 
-Export variables as `docker-args`
+Example output:
 
 ```bash
-dnl export docker-args --source .env
+-e NODE_ENV=test -e NODE_PORT=3000 -e FRONT_URL=https://example.com
 ```
 
-Result:
+See DNL documentation for more formats and options :
+→ [Read export documentation](docs/commands/export.md)
 
-```bash
--e "NODE_ENV=production" -e "NODE_PORT=3000"
-```
-
-Export for GitHub Actions (variables)
-
-```bash
-dnl export github-env
-```
-
-Result:
-
-```bash
-printf '%s\n' "NODE_ENV=production" >> $GITHUB_ENV
-printf '%s\n' "NODE_PORT=3000" >> $GITHUB_ENV
-```
-
-There are a few more formats and options (see CLI docs `dnl export --help`).
-
-## export types : Exporting TypeScript types
-
-`dnl export types` generates a `.d.ts` file describing the **static contract** of your environment variables.
-
-This file is intentionally **conservative**.
-
-### Transformed variables
-
-If a variable uses a Zod `transform`, the exported type always reflects the **input type**, not the runtime output.
-
-In that case:
-
-- a warning is emitted in the CLI
-- the generated type is annotated with `@dnl-transform`
-- the runtime value returned by `assert()` may differ
-
-This is a deliberate design choice to avoid lying to TypeScript.
+Export command is based on a plugin system, see how to implement your own exporter :
+→ [Read export plugins documentation](docs/commands/export-plugins.md)
 
 ## Real-life usage
 
@@ -416,6 +402,7 @@ Add `.dnl/` to your `.gitignore`.
 Using **dotenv-never-lies** via Git hooks is strongly recommended:
 
 - **pre-commit**: prevents committing if the local configuration is not compliant with the schema
+- **pre-commit**: prevents committing if local process.env is used (without annotation)
 - **post-merge**: immediately detects schema changes impacting the local environment
 
 The goal is simple:  
@@ -438,11 +425,13 @@ mkdir -p .githooks
 cat > .githooks/pre-commit <<'EOF'
 #!/bin/sh
 yarn dnl assert --source .env
+yarn dnl annotate --check --warn-as-error
 EOF
 
 cat > .githooks/post-merge <<'EOF'
 #!/bin/sh
 yarn dnl assert --source .env || true
+yarn dnl annotate --check --warn-as-error || true
 EOF
 
 chmod +x .githooks/pre-commit .githooks/post-merge
@@ -535,14 +524,6 @@ This validates the environment before startup, without changing runtime behavior
 
 > This is optional. It does not replace runtime validation.
 
-**Intellisens and JSdoc for env vars**
-
-After using `dnl export types` and importing the generated file, you get strong typing, auto-completion, IntelliSense and JSDoc for each environment variable.
-
-![IntelliSense and JSDoc for environment variables](docs/images/env-intellisense.png)
-
-> IntelliSense and JSDoc generated from the DNL schema after `dnl export types`.
-
 ## Common issues / Troubleshooting
 
 ### TypeScript projects with `rootDir: "src"`

package/dist/annotate/annotate-collector.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=annotate-collector.d.ts.map

package/dist/annotate/annotate-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotate-collector.d.ts","sourceRoot":"","sources":["../../src/annotate/annotate-collector.ts"],"names":[],"mappings":""}

package/dist/annotate/annotate-collector.js

@@ -0,0 +1,48 @@
+// import { Node, SourceFile } from "ts-morph";
+// import { getAnchor } from "../ast-tools/ast-helpers.js";
+// import { ProcessEnvUsages } from "../ast-tools/ast.types.js";
+export {};
+// export const collectProcessEnvUsages = (sourceFile: SourceFile): ProcessEnvUsages[] => {
+//     const accesses: ProcessEnvUsages[] = [];
+//     const relativeFilePath = sourceFile.getFilePath();
+//     for (const node of sourceFile.getDescendants()) {
+//         const pos = node.getSourceFile().getLineAndColumnAtPos(node.getStart());
+//         const anchor = getAnchor(node);
+//         if (!anchor) continue;
+//         // process.env.X
+//         if (Node.isPropertyAccessExpression(node)) {
+//             const expr = node.getExpression();
+//             // process.env.X
+//             if (expr.getText() === "process.env") {
+//                 accesses.push({ node, kind: "static", varName: node.getName(), anchor, relativeFilePath, pos });
+//                 continue;
+//             }
+//             // process.env (global access) — only if it is not a sub-node of process.env.X or process.env[...]
+//             if (Node.isIdentifier(expr) && expr.getText() === "process" && node.getName() === "env") {
+//                 const parent = node.getParent();
+//                 const isSubNodeOfSpecificAccess = parent && (Node.isPropertyAccessExpression(parent) || Node.isElementAccessExpression(parent));
+//                 if (!isSubNodeOfSpecificAccess) {
+//                     accesses.push({ node, kind: "global", anchor, relativeFilePath, pos });
+//                 }
+//                 continue;
+//             }
+//         }
+//         // process.env["X"] | process.env[key]
+//         if (Node.isElementAccessExpression(node)) {
+//             const expr = node.getExpression();
+//             if (expr.getText() === "process.env") {
+//                 const arg = node.getArgumentExpression();
+//                 // process.env["X"]
+//                 if (Node.isStringLiteral(arg)) {
+//                     accesses.push({ node, kind: "static", varName: arg.getLiteralText(), anchor, relativeFilePath, pos });
+//                 }
+//                 // process.env[key]
+//                 else {
+//                     accesses.push({ node, kind: "dynamic", anchor, relativeFilePath, pos });
+//                 }
+//                 continue;
+//             }
+//         }
+//     }
+//     return accesses;
+// };

package/dist/annotate/annotate-engine.d.ts

@@ -0,0 +1,8 @@
+import { AnnotateRuleContext } from "./types.js";
+import { ProcessEnvUsages } from "../ast-tools/ast.types.js";
+/**
+ * Processes a statement: all nodes are process.env usages from the same statement.
+ * A single issue is produced per statement.
+ */
+export declare const annotateEngine: (accesses: ProcessEnvUsages[], ctx: AnnotateRuleContext) => Promise<void>;
+//# sourceMappingURL=annotate-engine.d.ts.map

package/dist/annotate/annotate-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotate-engine.d.ts","sourceRoot":"","sources":["../../src/annotate/annotate-engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAI/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAM7D;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAU,UAAU,gBAAgB,EAAE,EAAE,KAAK,mBAAmB,KAAG,OAAO,CAAC,IAAI,CAwCzG,CAAC"}

package/dist/annotate/annotate-engine.js

@@ -0,0 +1,52 @@
+import path from "node:path";
+import { addAnnotationRule } from "./rules/add.js";
+import { removeAnnotationRule } from "./rules/remove.js";
+import { checkAnnotationRule } from "./rules/check.js";
+const RULES_ANNOTATE = [addAnnotationRule];
+const RULES_REMOVE = [removeAnnotationRule];
+const RULES_CHECK = [checkAnnotationRule];
+/**
+ * Processes a statement: all nodes are process.env usages from the same statement.
+ * A single issue is produced per statement.
+ */
+export const annotateEngine = async (accesses, ctx) => {
+    if (accesses.length === 0)
+        return;
+    const rules = ctx.mode === "remove" ? RULES_REMOVE : ctx.mode === "check" ? RULES_CHECK : RULES_ANNOTATE;
+    for (const rule of rules) {
+        if (!rule.match(accesses, ctx))
+            continue;
+        // Capture position and filePath before apply(): apply() may modify the AST
+        const filePath = path.relative(process.cwd(), ctx.sourceFile.getFilePath());
+        const issues = await rule.apply(accesses, ctx);
+        for (const issue of issues) {
+            ctx.report.issues.push({
+                filePath,
+                ...issue,
+            });
+            ctx.report.summary.accessesProcessed++;
+            switch (ctx.mode) {
+                case "remove":
+                    ctx.report.summary.commentsRemoved++;
+                    break;
+                case "check":
+                    if (issue.checkLevel === "error") {
+                        ctx.report.summary.checkErrors++;
+                    }
+                    else if (issue.checkLevel === "warning") {
+                        if (ctx.warnAsError) {
+                            ctx.report.summary.checkErrors++;
+                        }
+                        else {
+                            ctx.report.summary.checkWarnings++;
+                        }
+                    }
+                    break;
+                case "add":
+                    ctx.report.summary.commentsAdded++;
+                    break;
+            }
+        }
+        return;
+    }
+};

package/dist/annotate/annotate-remove-engine.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=annotate-remove-engine.d.ts.map

package/dist/annotate/annotate-remove-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotate-remove-engine.d.ts","sourceRoot":"","sources":["../../src/annotate/annotate-remove-engine.ts"],"names":[],"mappings":""}

package/dist/annotate/annotate-remove-engine.js

@@ -0,0 +1 @@
+export {};

package/dist/annotate/helper.d.ts

@@ -0,0 +1,26 @@
+import { Node } from "ts-morph";
+import type { CommentRange } from "ts-morph";
+import { DNLAnnotationType } from "./report.type.js";
+/**
+ * Check if the statement has a DNL annotation
+ * @param statement : the statement to check
+ * @param annotation : the annotation to check (optional). If undefined, check for any DNL annotation.
+ * @returns true if the statement has a DNL annotation, false otherwise
+ */
+export declare const hasDnlAnnotation: (statement: Node, annotation?: DNLAnnotationType | undefined) => boolean;
+/**
+ * Get the DNL annotation of the statement
+ * @param statement : the statement to check
+ * @returns the DNL annotation of the statement, or null if no annotation is found
+ */
+export declare const getDnlAnnotation: (statement: Node) => {
+    ranges: CommentRange[];
+    annotationTypes: DNLAnnotationType[] | null;
+} | null;
+/**
+ * Get the DNL annotation of the statement
+ * @param statement : the statement to check
+ * @returns the DNL annotation of the statement, or null if no annotation is found
+ */
+export declare const getDnlAnnotationType: (statement: Node) => DNLAnnotationType | null;
+//# sourceMappingURL=helper.d.ts.map

package/dist/annotate/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/annotate/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAkB,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,IAAI,EAAE,aAAY,iBAAiB,GAAG,SAAqB,KAAG,OAQzG,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,IAAI,KAAG;IAAE,MAAM,EAAE,YAAY,EAAE,CAAC;IAAC,eAAe,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAA;CAAE,GAAG,IA4B5H,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,IAAI,KAAG,iBAAiB,GAAG,IAqB1E,CAAC"}

package/dist/annotate/helper.js

@@ -0,0 +1,76 @@
+import { DNL_ANNOTATION } from "./report.type.js";
+/**
+ * Check if the statement has a DNL annotation
+ * @param statement : the statement to check
+ * @param annotation : the annotation to check (optional). If undefined, check for any DNL annotation.
+ * @returns true if the statement has a DNL annotation, false otherwise
+ */
+export const hasDnlAnnotation = (statement, annotation = undefined) => {
+    const ranges = statement.getLeadingCommentRanges();
+    if (!ranges || ranges.length < 1)
+        return false;
+    if (annotation) {
+        return ranges.some((c) => c.getText().includes(annotation));
+    }
+    return ranges.some((c) => Object.values(DNL_ANNOTATION).some((a) => c.getText().includes(a)));
+};
+/**
+ * Get the DNL annotation of the statement
+ * @param statement : the statement to check
+ * @returns the DNL annotation of the statement, or null if no annotation is found
+ */
+export const getDnlAnnotation = (statement) => {
+    const ranges = statement.getLeadingCommentRanges();
+    // if there are other comments above the dnl annotation, we ignore them (to not delete them, they are not ours)
+    while (ranges.length > 0 && !ranges[0].getText().includes("@dnl-")) {
+        ranges.shift();
+    }
+    if (ranges.length < 1)
+        return null;
+    // Collect annotations in the order of their first occurrence in the text
+    const annotationTypes = [];
+    for (const range of ranges) {
+        const text = range.getText();
+        const withPosition = [];
+        for (const annotation of Object.values(DNL_ANNOTATION)) {
+            const index = text.indexOf(annotation);
+            if (index !== -1) {
+                withPosition.push({ annotation, index });
+            }
+        }
+        withPosition.sort((a, b) => a.index - b.index);
+        for (const { annotation } of withPosition) {
+            annotationTypes.push(annotation);
+        }
+    }
+    // We know annotationType is not null here (passed through a rule's match).
+    // Set a default in fallback, but this should not happen.
+    return { ranges, annotationTypes };
+};
+/**
+ * Get the DNL annotation of the statement
+ * @param statement : the statement to check
+ * @returns the DNL annotation of the statement, or null if no annotation is found
+ */
+export const getDnlAnnotationType = (statement) => {
+    const ranges = statement.getLeadingCommentRanges();
+    // if there are other comments above the dnl annotation, we ignore them (to not delete them, they are not ours)
+    while (ranges.length > 0 && !ranges[0].getText().includes("@dnl-")) {
+        ranges.shift();
+    }
+    if (ranges.length < 1)
+        return null;
+    for (const range of ranges) {
+        const text = range.getText();
+        let earliest = null;
+        for (const annotation of Object.values(DNL_ANNOTATION)) {
+            const index = text.indexOf(annotation);
+            if (index !== -1 && (earliest === null || index < earliest.index)) {
+                earliest = { annotation, index };
+            }
+        }
+        if (earliest !== null)
+            return earliest.annotation;
+    }
+    return null;
+};

package/dist/annotate/report.type.d.ts

@@ -0,0 +1,43 @@
+export declare const DNL_ANNOTATION: {
+    readonly recommendation: "@dnl-recommendation";
+    readonly ignore: "@dnl-ignore";
+    readonly dynamic: "@dnl-dynamic-access";
+    readonly global: "@dnl-global-access";
+    readonly unknown: "@dnl-unknown";
+};
+export type DNLAnnotationType = (typeof DNL_ANNOTATION)[keyof typeof DNL_ANNOTATION];
+export type RemovalRange = {
+    start: number;
+    end: number;
+};
+export type CheckLevel = "error" | "warning" | "info";
+export type AnnotateEnvRuleIssue = {
+    nodeText: string;
+    annotation: DNLAnnotationType | null;
+    messages: string[];
+    pos?: {
+        line: number;
+        column: number;
+    };
+    removalRange?: RemovalRange;
+    checkLevel?: CheckLevel;
+};
+export type AnnotateIssue = AnnotateEnvRuleIssue & {
+    filePath: string;
+};
+export type AnnotateSummary = {
+    filesScanned: number;
+    accessesProcessed: number;
+    commentsAdded: number;
+    commentsRemoved: number;
+    checkErrors: number;
+    checkWarnings: number;
+};
+export type AnnotateMode = "check" | "remove" | "add";
+export type AnnotateReport = {
+    type: "annotate";
+    mode: AnnotateMode;
+    issues: AnnotateIssue[];
+    summary: AnnotateSummary;
+};
+//# sourceMappingURL=report.type.d.ts.map

package/dist/annotate/report.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.type.d.ts","sourceRoot":"","sources":["../../src/annotate/report.type.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;;;;CAMjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAErF,MAAM,MAAM,YAAY,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1D,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AACtD,MAAM,MAAM,oBAAoB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACrC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,UAAU,CAAC,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,oBAAoB,GAAG;IAC/C,QAAQ,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;AACtD,MAAM,MAAM,cAAc,GAAG;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,eAAe,CAAC;CAC5B,CAAC"}

package/dist/annotate/report.type.js

@@ -0,0 +1,7 @@
+export const DNL_ANNOTATION = {
+    recommendation: "@dnl-recommendation",
+    ignore: "@dnl-ignore",
+    dynamic: "@dnl-dynamic-access",
+    global: "@dnl-global-access",
+    unknown: "@dnl-unknown",
+};

package/dist/annotate/rules/add.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const addAnnotationRule: AnnotateRule;
+//# sourceMappingURL=add.d.ts.map

package/dist/annotate/rules/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/add.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAM3C,eAAO,MAAM,iBAAiB,EAAE,YAqE/B,CAAC"}