@kensio/yulin 1.9.0 → 1.10.1

package/README.md

@@ -31,6 +31,7 @@ npm i -D @kensio/yulin
 - [Route53](./docs/services/route53 "Simulated Route53 docs")
 - [S3](./docs/services/s3 "Simulated S3 docs")
 - [Secrets Manager](./docs/services/secretsmanager "Simulated Secrets Manager docs")
+- [SNS](./docs/services/sns "Simulated SNS docs")
 - [SQS](./docs/services/sqs "Simulated SQS docs")
 - [SSM Parameter Store](./docs/services/ssm "Simulated SSM Parameter Store docs")
 - [STS](./docs/services/sts "Simulated STS docs")
@@ -197,6 +198,30 @@ console.log(bucketWebsiteUrl.toString());
 const res = await fetch(new URL("/foo/", bucketWebsiteUrl));
 ```
 
+#### Send requests without a port
+
+A test usually wants the same requests with nothing listening. `SimAwsHttp` answers a Fetch API
+`Request` with a `Response` in process, so there is no port for parallel test files to collide over,
+and no server to start or tear down:
+
+```typescript
+import { SimAws } from "@kensio/yulin";
+import { SimAwsHttp } from "@kensio/yulin/serve";
+
+const simAws = new SimAws();
+const simAwsHttp = new SimAwsHttp({ simAws });
+
+// Build the simulated environment the requests are answered from here.
+
+const response = await simAwsHttp.fetch("https://www.example.com/");
+```
+
+Nothing binds a port, so a URL a simulated service gives out is fetched as it is, with no
+`localUrl(...)` adapting, and a hostname a simulated Route53 answers for is requested by its own
+name. Both routes go through the same authentication, routing and service code, so `serveSimAws` is
+what you want only when the request comes from outside the process. See the
+[serving docs](./docs/serve "Serving simulated AWS on localhost docs") for which to reach for.
+
 #### Restarting a served environment
 
 A served environment takes an available port by default, so the URL changes every time the process

package/dist/config/eslint/cffjs2.eslint.config.js

@@ -1,5 +1,13 @@
+import {} from "eslint";
 import { defineConfig } from "eslint/config";
 import tseslint from "typescript-eslint";
+import { cffJs2LintPlugin, cffJs2LintRules, cffJs2PluginName, } from "../lint/index.js";
+// ESLint's `Plugin` describes a rule context far wider than these rules read:
+// it is generic over the syntax tree, so a rule typed against the handful of
+// node properties it actually touches cannot satisfy it. This file is the
+// adapter that wires a linter-agnostic plugin into ESLint, so it is where that
+// difference belongs.
+const eslintPlugin = cffJs2LintPlugin;
 export default defineConfig({
     // ── CloudFront Functions JS2
     files: ["**/*.cff.js"],
@@ -9,107 +17,18 @@ export default defineConfig({
             projectService: false,
         },
     },
+    plugins: {
+        // The restrictions live in a plugin rather than in `no-restricted-syntax`
+        // so that Oxlint can load the same rules, and so that switching one off
+        // does not mean restating the rest. See `../lint/cff-js2-lint-plugin.ts`.
+        [cffJs2PluginName]: eslintPlugin,
+    },
     rules: {
-        "no-var": "off",
-        "prefer-const": "off",
-        "object-shorthand": "off",
-        "prefer-template": "off",
+        ...cffJs2LintRules(),
+        // ── ESLint-only, because typescript-eslint's own copies of these rules
+        //    take over from the built-in ones in a TypeScript-aware config.
         "@typescript-eslint/explicit-function-return-type": "off",
         "@typescript-eslint/explicit-module-boundary-types": "off",
-        "no-eval": "error",
-        "no-new-func": "error",
-        "no-implied-eval": "error",
-        "no-restricted-globals": [
-            "error",
-            {
-                name: "fetch",
-                message: "CloudFront Functions cannot make network requests.",
-            },
-            {
-                name: "XMLHttpRequest",
-                message: "CloudFront Functions cannot make network requests.",
-            },
-            {
-                name: "WebSocket",
-                message: "CloudFront Functions cannot open network connections.",
-            },
-            {
-                name: "require",
-                message: "CloudFront Functions must be self-contained and cannot require modules.",
-            },
-            {
-                name: "process",
-                message: "CloudFront Functions do not have access to Node.js process APIs.",
-            },
-            {
-                name: "Buffer",
-                message: "CloudFront Functions do not have access to Node.js Buffer.",
-            },
-            {
-                name: "setTimeout",
-                message: "CloudFront Functions do not support timers.",
-            },
-            {
-                name: "setInterval",
-                message: "CloudFront Functions do not support timers.",
-            },
-            {
-                name: "setImmediate",
-                message: "CloudFront Functions do not support timers.",
-            },
-            {
-                name: "Promise",
-                message: "Avoid Promise usage in CloudFront Functions.",
-            },
-        ],
-        "no-restricted-syntax": [
-            "error",
-            {
-                selector: "TemplateLiteral",
-                message: "CloudFront Functions JS2 does not support template literals. Use string concatenation instead.",
-            },
-            {
-                selector: "ImportDeclaration",
-                message: "CloudFront Functions must be self-contained and should not use import syntax.",
-            },
-            {
-                selector: "ExportNamedDeclaration:not([declaration.type='FunctionDeclaration'][declaration.id.name='handler'])",
-                message: "CloudFront Function files may only export the handler as `export function handler(...)`.",
-            },
-            {
-                selector: "ExportDefaultDeclaration, ExportAllDeclaration",
-                message: "CloudFront Function files may only export the handler as `export function handler(...)`.",
-            },
-            {
-                selector: "ClassDeclaration, ClassExpression",
-                message: "Avoid class syntax in CloudFront Functions JS2 files.",
-            },
-            {
-                selector: "ArrowFunctionExpression",
-                message: "Avoid arrow functions in CloudFront Functions JS2 files. Use function declarations/expressions instead.",
-            },
-            {
-                selector: "AwaitExpression, FunctionDeclaration[async=true], FunctionExpression[async=true], ArrowFunctionExpression[async=true]",
-                message: "CloudFront Functions should not use async/await.",
-            },
-            {
-                selector: "YieldExpression, FunctionDeclaration[generator=true], FunctionExpression[generator=true]",
-                message: "CloudFront Functions should not use generators.",
-            },
-            {
-                selector: "ObjectPattern, ArrayPattern",
-                message: "Avoid destructuring in CloudFront Functions JS2 files.",
-            },
-            {
-                selector: "SpreadElement, RestElement",
-                message: "Avoid spread/rest syntax in CloudFront Functions JS2 files.",
-            },
-            {
-                selector: "ForOfStatement",
-                message: "Avoid for...of in CloudFront Functions JS2 files. Use index-based loops instead.",
-            },
-        ],
-        "no-unused-vars": ["error", { varsIgnorePattern: "^handler$" }],
         "@typescript-eslint/no-unused-vars": [
             "error",
             { varsIgnorePattern: "^handler$" },

package/dist/config/eslint/cffjs2.eslint.config.js.map

@@ -1 +1 @@
-{"version":3,"file":"cffjs2.eslint.config.js","sourceRoot":"","sources":["../../../src/config/eslint/cffjs2.eslint.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,QAAQ,MAAM,mBAAmB,CAAC;AAEzC,eAAe,YAAY,CAAC;IAC1B,8BAA8B;IAC9B,KAAK,EAAE,CAAC,aAAa,CAAC;IACtB,OAAO,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC;IAC9C,eAAe,EAAE;QACf,aAAa,EAAE;YACb,cAAc,EAAE,KAAK;SACtB;KACF;IACD,KAAK,EAAE;QACL,QAAQ,EAAE,KAAK;QACf,cAAc,EAAE,KAAK;QACrB,kBAAkB,EAAE,KAAK;QACzB,iBAAiB,EAAE,KAAK;QACxB,kDAAkD,EAAE,KAAK;QACzD,mDAAmD,EAAE,KAAK;QAC1D,SAAS,EAAE,OAAO;QAClB,aAAa,EAAE,OAAO;QACtB,iBAAiB,EAAE,OAAO;QAC1B,uBAAuB,EAAE;YACvB,OAAO;YACP;gBACE,IAAI,EAAE,OAAO;gBACb,OAAO,EAAE,oDAAoD;aAC9D;YACD;gBACE,IAAI,EAAE,gBAAgB;gBACtB,OAAO,EAAE,oDAAoD;aAC9D;YACD;gBACE,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,uDAAuD;aACjE;YACD;gBACE,IAAI,EAAE,SAAS;gBACf,OAAO,EACL,yEAAyE;aAC5E;YACD;gBACE,IAAI,EAAE,SAAS;gBACf,OAAO,EACL,kEAAkE;aACrE;YACD;gBACE,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,4DAA4D;aACtE;YACD;gBACE,IAAI,EAAE,YAAY;gBAClB,OAAO,EAAE,6CAA6C;aACvD;YACD;gBACE,IAAI,EAAE,aAAa;gBACnB,OAAO,EAAE,6CAA6C;aACvD;YACD;gBACE,IAAI,EAAE,cAAc;gBACpB,OAAO,EAAE,6CAA6C;aACvD;YACD;gBACE,IAAI,EAAE,SAAS;gBACf,OAAO,EAAE,8CAA8C;aACxD;SACF;QACD,sBAAsB,EAAE;YACtB,OAAO;YACP;gBACE,QAAQ,EAAE,iBAAiB;gBAC3B,OAAO,EACL,gGAAgG;aACnG;YACD;gBACE,QAAQ,EAAE,mBAAmB;gBAC7B,OAAO,EACL,+EAA+E;aAClF;YACD;gBACE,QAAQ,EACN,qGAAqG;gBACvG,OAAO,EACL,0FAA0F;aAC7F;YACD;gBACE,QAAQ,EAAE,gDAAgD;gBAC1D,OAAO,EACL,0FAA0F;aAC7F;YACD;gBACE,QAAQ,EAAE,mCAAmC;gBAC7C,OAAO,EAAE,uDAAuD;aACjE;YACD;gBACE,QAAQ,EAAE,yBAAyB;gBACnC,OAAO,EACL,yGAAyG;aAC5G;YACD;gBACE,QAAQ,EACN,uHAAuH;gBACzH,OAAO,EAAE,kDAAkD;aAC5D;YACD;gBACE,QAAQ,EACN,0FAA0F;gBAC5F,OAAO,EAAE,iDAAiD;aAC3D;YACD;gBACE,QAAQ,EAAE,6BAA6B;gBACvC,OAAO,EAAE,wDAAwD;aAClE;YACD;gBACE,QAAQ,EAAE,4BAA4B;gBACtC,OAAO,EAAE,6DAA6D;aACvE;YACD;gBACE,QAAQ,EAAE,gBAAgB;gBAC1B,OAAO,EACL,kFAAkF;aACrF;SACF;QACD,gBAAgB,EAAE,CAAC,OAAO,EAAE,EAAE,iBAAiB,EAAE,WAAW,EAAE,CAAC;QAC/D,mCAAmC,EAAE;YACnC,OAAO;YACP,EAAE,iBAAiB,EAAE,WAAW,EAAE;SACnC;KACF;CACF,CAAC,CAAC"}
+{"version":3,"file":"cffjs2.eslint.config.js","sourceRoot":"","sources":["../../../src/config/eslint/cffjs2.eslint.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,QAAQ,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAE1B,8EAA8E;AAC9E,6EAA6E;AAC7E,0EAA0E;AAC1E,+EAA+E;AAC/E,sBAAsB;AACtB,MAAM,YAAY,GAAG,gBAA4C,CAAC;AAElE,eAAe,YAAY,CAAC;IAC1B,8BAA8B;IAC9B,KAAK,EAAE,CAAC,aAAa,CAAC;IACtB,OAAO,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC;IAC9C,eAAe,EAAE;QACf,aAAa,EAAE;YACb,cAAc,EAAE,KAAK;SACtB;KACF;IACD,OAAO,EAAE;QACP,0EAA0E;QAC1E,wEAAwE;QACxE,0EAA0E;QAC1E,CAAC,gBAAgB,CAAC,EAAE,YAAY;KACjC;IACD,KAAK,EAAE;QACL,GAAG,eAAe,EAAE;QAEpB,wEAAwE;QACxE,oEAAoE;QACpE,kDAAkD,EAAE,KAAK;QACzD,mDAAmD,EAAE,KAAK;QAC1D,mCAAmC,EAAE;YACnC,OAAO;YACP,EAAE,iBAAiB,EAAE,WAAW,EAAE;SACnC;KACF;CACF,CAAC,CAAC"}

package/dist/config/lint/cff-js2-lint-plugin.d.ts

@@ -0,0 +1,16 @@
+import type { LintPlugin } from "./lint-plugin.type.js";
+/**
+ * The name both linters report these rules under.
+ */
+export declare const cffJs2PluginName = "cff-js2";
+/**
+ * A lint plugin holding what CloudFront Functions JS2 refuses to run.
+ *
+ * The same object loads into ESLint as a plugin and into Oxlint as a JS
+ * plugin, because both walk the tree with the same selector syntax and hand a
+ * rule the same context. Publishing it as rules rather than as a
+ * `no-restricted-syntax` block is what makes that possible, and it also lets a
+ * consumer switch off one restriction without restating the other ten.
+ */
+export declare const cffJs2LintPlugin: LintPlugin;
+//# sourceMappingURL=cff-js2-lint-plugin.d.ts.map

package/dist/config/lint/cff-js2-lint-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-lint-plugin.d.ts","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-lint-plugin.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,UAAU,EAIX,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAyB1C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,UAG9B,CAAC"}

package/dist/config/lint/cff-js2-lint-plugin.js

@@ -0,0 +1,39 @@
+import { cffJs2SyntaxRestrictions, cffJs2UnavailableGlobalRuleName, } from "./cff-js2-restriction.js";
+import { cffJs2UnavailableGlobalRule } from "./cff-js2-unavailable-global.rule.js";
+/**
+ * The name both linters report these rules under.
+ */
+export const cffJs2PluginName = "cff-js2";
+function syntaxRule(selector, message) {
+    return {
+        meta: { type: "problem", schema: [], messages: { unsupported: message } },
+        create: (context) => ({
+            [selector]: (node) => {
+                context.report({ node, messageId: "unsupported" });
+            },
+        }),
+    };
+}
+function buildRules() {
+    return {
+        [cffJs2UnavailableGlobalRuleName]: cffJs2UnavailableGlobalRule(),
+        ...Object.fromEntries(Object.entries(cffJs2SyntaxRestrictions).map(([name, restriction]) => [
+            name,
+            syntaxRule(restriction.selector, restriction.message),
+        ])),
+    };
+}
+/**
+ * A lint plugin holding what CloudFront Functions JS2 refuses to run.
+ *
+ * The same object loads into ESLint as a plugin and into Oxlint as a JS
+ * plugin, because both walk the tree with the same selector syntax and hand a
+ * rule the same context. Publishing it as rules rather than as a
+ * `no-restricted-syntax` block is what makes that possible, and it also lets a
+ * consumer switch off one restriction without restating the other ten.
+ */
+export const cffJs2LintPlugin = {
+    meta: { name: cffJs2PluginName },
+    rules: buildRules(),
+};
+//# sourceMappingURL=cff-js2-lint-plugin.js.map

package/dist/config/lint/cff-js2-lint-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-lint-plugin.js","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-lint-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,+BAA+B,GAChC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AASnF;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,SAAS,CAAC;AAE1C,SAAS,UAAU,CAAC,QAAgB,EAAE,OAAe;IACnD,OAAO;QACL,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE;QACzE,MAAM,EAAE,CAAC,OAAwB,EAAe,EAAE,CAAC,CAAC;YAClD,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAc,EAAQ,EAAE;gBACnC,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC;YACrD,CAAC;SACF,CAAC;KACH,CAAC;AACJ,CAAC;AAED,SAAS,UAAU;IACjB,OAAO;QACL,CAAC,+BAA+B,CAAC,EAAE,2BAA2B,EAAE;QAChE,GAAG,MAAM,CAAC,WAAW,CACnB,MAAM,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC;YACpE,IAAI;YACJ,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC;SACtD,CAAC,CACH;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAe;IAC1C,IAAI,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE;IAChC,KAAK,EAAE,UAAU,EAAE;CACpB,CAAC"}

package/dist/config/lint/cff-js2-lint-rules.d.ts

@@ -0,0 +1,20 @@
+/**
+ * One rule setting, in the form both linters read it.
+ */
+export type LintRuleSetting = "off" | "error" | readonly ["error", Readonly<Record<string, string>>];
+/**
+ * Every rule in the plugin, turned on, under the name the plugin is loaded as.
+ *
+ * Deriving this from the plugin keeps a rule from being added without either
+ * published config picking it up.
+ */
+export declare function cffJs2LintPluginRules(): Record<string, "error">;
+/**
+ * Every rule a CloudFront Functions JS2 file should be linted with, in the
+ * form ESLint and Oxlint both accept.
+ *
+ * Both published configs derive their rules from here, so a restriction cannot
+ * be added for one linter and forgotten for the other.
+ */
+export declare function cffJs2LintRules(): Record<string, LintRuleSetting>;
+//# sourceMappingURL=cff-js2-lint-rules.d.ts.map

package/dist/config/lint/cff-js2-lint-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-lint-rules.d.ts","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-lint-rules.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,eAAe,GACzB,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;AA6BzE;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAO/D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAMjE"}

package/dist/config/lint/cff-js2-lint-rules.js

@@ -0,0 +1,53 @@
+import { cffJs2LintPlugin, cffJs2PluginName } from "./cff-js2-lint-plugin.js";
+/**
+ * Rules a general JavaScript config turns on that JS2 cannot satisfy.
+ *
+ * Only advice the runtime makes impossible is relaxed. `const`, `let` and
+ * template literals are all supported in JS2, so the rules asking for them
+ * stay on: switching them off would tell a reader that `var` and string
+ * concatenation are required here, which is its own kind of wrong answer.
+ *
+ * Shorthand object properties are ES 6 literal syntax the runtime's feature
+ * list does not name, so that one is genuinely unavailable.
+ */
+const relaxedRules = {
+    "object-shorthand": "off",
+};
+/**
+ * Restrictions both linters already ship, so the plugin does not repeat them.
+ */
+const builtInRules = {
+    "no-eval": "error",
+    "no-new-func": "error",
+    "no-implied-eval": "error",
+    // The handler is the entry point CloudFront calls rather than anything this
+    // file uses, so it is not unused merely because nothing here reads it.
+    "no-unused-vars": ["error", { varsIgnorePattern: "^handler$" }],
+};
+/**
+ * Every rule in the plugin, turned on, under the name the plugin is loaded as.
+ *
+ * Deriving this from the plugin keeps a rule from being added without either
+ * published config picking it up.
+ */
+export function cffJs2LintPluginRules() {
+    return Object.fromEntries(Object.keys(cffJs2LintPlugin.rules).map((name) => [
+        `${cffJs2PluginName}/${name}`,
+        "error",
+    ]));
+}
+/**
+ * Every rule a CloudFront Functions JS2 file should be linted with, in the
+ * form ESLint and Oxlint both accept.
+ *
+ * Both published configs derive their rules from here, so a restriction cannot
+ * be added for one linter and forgotten for the other.
+ */
+export function cffJs2LintRules() {
+    return {
+        ...relaxedRules,
+        ...builtInRules,
+        ...cffJs2LintPluginRules(),
+    };
+}
+//# sourceMappingURL=cff-js2-lint-rules.js.map

package/dist/config/lint/cff-js2-lint-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-lint-rules.js","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-lint-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAQ9E;;;;;;;;;;GAUG;AACH,MAAM,YAAY,GAA8C;IAC9D,kBAAkB,EAAE,KAAK;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,YAAY,GAA8C;IAC9D,SAAS,EAAE,OAAO;IAClB,aAAa,EAAE,OAAO;IACtB,iBAAiB,EAAE,OAAO;IAC1B,4EAA4E;IAC5E,uEAAuE;IACvE,gBAAgB,EAAE,CAAC,OAAO,EAAE,EAAE,iBAAiB,EAAE,WAAW,EAAE,CAAC;CAChE,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QAChD,GAAG,gBAAgB,IAAI,IAAI,EAAE;QAC7B,OAAO;KACR,CAAC,CACH,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,GAAG,YAAY;QACf,GAAG,YAAY;QACf,GAAG,qBAAqB,EAAE;KAC3B,CAAC;AACJ,CAAC"}

package/dist/config/lint/cff-js2-lint.fixture.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A CloudFront Function that stays inside what JS2 will run.
+ *
+ * It deliberately uses the ES 6 and ES 8 features the runtime's feature list
+ * does name: `const`, `let`, template literals, arrow functions, rest
+ * parameters and `async`/`await`. An earlier version of this config refused
+ * all of those, so a fixture that only used ES 5.1 would have passed against
+ * rules that were wrong.
+ */
+export declare const supportedCffJs2Source = "const suffix = \"index.html\";\n\nconst withSuffix = (uri) => `${uri}${suffix}`;\n\nfunction firstDefined(...candidates) {\n  for (var index = 0; index < candidates.length; index++) {\n    if (candidates[index] !== undefined) {\n      return candidates[index];\n    }\n  }\n\n  return undefined;\n}\n\nexport async function handler(event) {\n  const request = event.request;\n  let uri = firstDefined(request.uri, \"/\");\n\n  if (uri.charAt(uri.length - 1) === \"/\") {\n    uri = withSuffix(uri);\n  }\n\n  request.uri = await Promise.resolve(uri);\n\n  return request;\n}\n";
+/**
+ * One construct JS2 refuses, and the rule that should say so.
+ */
+export interface CffJs2Violation {
+    readonly rule: string;
+    readonly what: string;
+    readonly source: string;
+}
+/**
+ * A case per restriction, each written the way the mistake actually shows up.
+ *
+ * Every rule in the plugin needs one, so that a rule whose selector stops
+ * matching is a failing test rather than a quiet gap in what gets caught.
+ * A case may trip more than one rule — unsupported syntax tends to arrive in
+ * company — so what each asserts is that its own rule is among the findings.
+ */
+export declare const cffJs2Violations: readonly CffJs2Violation[];
+/**
+ * Syntax JS2 does support, which no rule may report.
+ *
+ * These are here because each one was refused by an earlier version of this
+ * config, and a rule that sends a reader away from working code is worse than
+ * no rule at all.
+ */
+export declare const supportedCffJs2Cases: readonly {
+    readonly what: string;
+    readonly source: string;
+}[];
+//# sourceMappingURL=cff-js2-lint.fixture.d.ts.map

package/dist/config/lint/cff-js2-lint.fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-lint.fixture.d.ts","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-lint.fixture.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,qkBA0BjC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,eAAe,EA2GtD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,EAoEA,CAAC"}

package/dist/config/lint/cff-js2-lint.fixture.js

@@ -0,0 +1,229 @@
+/**
+ * A CloudFront Function that stays inside what JS2 will run.
+ *
+ * It deliberately uses the ES 6 and ES 8 features the runtime's feature list
+ * does name: `const`, `let`, template literals, arrow functions, rest
+ * parameters and `async`/`await`. An earlier version of this config refused
+ * all of those, so a fixture that only used ES 5.1 would have passed against
+ * rules that were wrong.
+ */
+export const supportedCffJs2Source = `const suffix = "index.html";
+
+const withSuffix = (uri) => \`\${uri}\${suffix}\`;
+
+function firstDefined(...candidates) {
+  for (var index = 0; index < candidates.length; index++) {
+    if (candidates[index] !== undefined) {
+      return candidates[index];
+    }
+  }
+
+  return undefined;
+}
+
+export async function handler(event) {
+  const request = event.request;
+  let uri = firstDefined(request.uri, "/");
+
+  if (uri.charAt(uri.length - 1) === "/") {
+    uri = withSuffix(uri);
+  }
+
+  request.uri = await Promise.resolve(uri);
+
+  return request;
+}
+`;
+/**
+ * A case per restriction, each written the way the mistake actually shows up.
+ *
+ * Every rule in the plugin needs one, so that a rule whose selector stops
+ * matching is a failing test rather than a quiet gap in what gets caught.
+ * A case may trip more than one rule — unsupported syntax tends to arrive in
+ * company — so what each asserts is that its own rule is among the findings.
+ */
+export const cffJs2Violations = [
+    {
+        rule: "no-import",
+        what: "an import",
+        source: `import { helper } from "./helper.js";
+
+export function handler() {
+  return helper();
+}
+`,
+    },
+    {
+        rule: "only-handler-export",
+        what: "an export other than the handler",
+        source: `export var version = 1;
+
+export function handler() {}
+`,
+    },
+    {
+        rule: "only-handler-export",
+        what: "a default export",
+        source: `export default function handler() {}
+`,
+    },
+    {
+        rule: "only-handler-export",
+        what: "a re-export",
+        source: `export * from "./helper.js";
+`,
+    },
+    {
+        rule: "only-built-in-require",
+        what: "requiring a module the runtime does not have",
+        source: `var fs = require("node:fs");
+
+export function handler(event) {
+  return fs.readFileSync(event.request.uri);
+}
+`,
+    },
+    {
+        rule: "no-class",
+        what: "a class",
+        source: `class Router {}
+
+export function handler() {
+  return new Router();
+}
+`,
+    },
+    {
+        rule: "no-generator",
+        what: "a generator",
+        source: `function* each() {
+  yield 1;
+}
+
+export function handler() {
+  return each();
+}
+`,
+    },
+    {
+        rule: "no-destructuring",
+        what: "destructuring",
+        source: `export function handler(event) {
+  const { request } = event;
+
+  return request;
+}
+`,
+    },
+    {
+        rule: "no-spread",
+        what: "spread syntax",
+        source: `export function handler(event) {
+  const headers = [event.request];
+
+  return [...headers, event];
+}
+`,
+    },
+    {
+        rule: "no-for-of",
+        what: "a for...of loop",
+        source: `export function handler(event) {
+  let total = 0;
+
+  for (const value of event.values) {
+    total = total + value;
+  }
+
+  return total;
+}
+`,
+    },
+    {
+        rule: "no-unavailable-global",
+        what: "a global the runtime does not have",
+        source: `export function handler(event) {
+  fetch("https://example.test");
+
+  return event;
+}
+`,
+    },
+];
+/**
+ * Syntax JS2 does support, which no rule may report.
+ *
+ * These are here because each one was refused by an earlier version of this
+ * config, and a rule that sends a reader away from working code is worse than
+ * no rule at all.
+ */
+export const supportedCffJs2Cases = [
+    {
+        what: "a template literal",
+        source: "export function handler(event) {\n  return `/` + event.id;\n}\n",
+    },
+    {
+        what: "an arrow function",
+        source: `export function handler(event) {
+  const pick = () => event.request;
+
+  return pick();
+}
+`,
+    },
+    {
+        what: "async and await",
+        source: `export async function handler(event) {
+  return await Promise.resolve(event.request);
+}
+`,
+    },
+    {
+        what: "rest parameters",
+        source: `function first(...values) {
+  return values[0];
+}
+
+export function handler(event) {
+  return first(event.request);
+}
+`,
+    },
+    {
+        what: "a Promise",
+        source: `export function handler(event) {
+  return Promise.resolve(event.request);
+}
+`,
+    },
+    {
+        what: "a Buffer",
+        source: `export function handler(event) {
+  return Buffer.from(event.request.uri, "utf8").toString("base64");
+}
+`,
+    },
+    {
+        what: "requiring a built-in module",
+        source: `var crypto = require("crypto");
+
+export function handler(event) {
+  return crypto.createHash("sha256").update(event.request.uri).digest("hex");
+}
+`,
+    },
+    {
+        what: "const and let",
+        source: `export function handler(event) {
+  const request = event.request;
+  let uri = request.uri;
+
+  uri = uri + "/index.html";
+  request.uri = uri;
+
+  return request;
+}
+`,
+    },
+];
+//# sourceMappingURL=cff-js2-lint.fixture.js.map

package/dist/config/lint/cff-js2-lint.fixture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-lint.fixture.js","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-lint.fixture.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BpC,CAAC;AAWF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA+B;IAC1D;QACE,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,WAAW;QACjB,MAAM,EAAE;;;;;CAKX;KACE;IACD;QACE,IAAI,EAAE,qBAAqB;QAC3B,IAAI,EAAE,kCAAkC;QACxC,MAAM,EAAE;;;CAGX;KACE;IACD;QACE,IAAI,EAAE,qBAAqB;QAC3B,IAAI,EAAE,kBAAkB;QACxB,MAAM,EAAE;CACX;KACE;IACD;QACE,IAAI,EAAE,qBAAqB;QAC3B,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE;CACX;KACE;IACD;QACE,IAAI,EAAE,uBAAuB;QAC7B,IAAI,EAAE,8CAA8C;QACpD,MAAM,EAAE;;;;;CAKX;KACE;IACD;QACE,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,SAAS;QACf,MAAM,EAAE;;;;;CAKX;KACE;IACD;QACE,IAAI,EAAE,cAAc;QACpB,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE;;;;;;;CAOX;KACE;IACD;QACE,IAAI,EAAE,kBAAkB;QACxB,IAAI,EAAE,eAAe;QACrB,MAAM,EAAE;;;;;CAKX;KACE;IACD;QACE,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,eAAe;QACrB,MAAM,EAAE;;;;;CAKX;KACE;IACD;QACE,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,iBAAiB;QACvB,MAAM,EAAE;;;;;;;;;CASX;KACE;IACD;QACE,IAAI,EAAE,uBAAuB;QAC7B,IAAI,EAAE,oCAAoC;QAC1C,MAAM,EAAE;;;;;CAKX;KACE;CACF,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAG3B;IACJ;QACE,IAAI,EAAE,oBAAoB;QAC1B,MAAM,EAAE,iEAAiE;KAC1E;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,MAAM,EAAE;;;;;CAKX;KACE;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,MAAM,EAAE;;;CAGX;KACE;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,MAAM,EAAE;;;;;;;CAOX;KACE;IACD;QACE,IAAI,EAAE,WAAW;QACjB,MAAM,EAAE;;;CAGX;KACE;IACD;QACE,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE;;;CAGX;KACE;IACD;QACE,IAAI,EAAE,6BAA6B;QACnC,MAAM,EAAE;;;;;CAKX;KACE;IACD;QACE,IAAI,EAAE,eAAe;QACrB,MAAM,EAAE;;;;;;;;;CASX;KACE;CACF,CAAC"}

package/dist/config/lint/cff-js2-oxlint-plugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The plugin entry point Oxlint loads.
+ *
+ * Oxlint reads a JS plugin from a module's default export, where ESLint takes
+ * the plugin object from wherever a config puts it, so this file exists only
+ * to present the same plugin the way Oxlint expects to find it.
+ */
+export { cffJs2LintPlugin as default } from "./cff-js2-lint-plugin.js";
+//# sourceMappingURL=cff-js2-oxlint-plugin.d.ts.map

package/dist/config/lint/cff-js2-oxlint-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-oxlint-plugin.d.ts","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-oxlint-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,gBAAgB,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/config/lint/cff-js2-oxlint-plugin.js

@@ -0,0 +1,9 @@
+/**
+ * The plugin entry point Oxlint loads.
+ *
+ * Oxlint reads a JS plugin from a module's default export, where ESLint takes
+ * the plugin object from wherever a config puts it, so this file exists only
+ * to present the same plugin the way Oxlint expects to find it.
+ */
+export { cffJs2LintPlugin as default } from "./cff-js2-lint-plugin.js";
+//# sourceMappingURL=cff-js2-oxlint-plugin.js.map

package/dist/config/lint/cff-js2-oxlint-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-oxlint-plugin.js","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-oxlint-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,gBAAgB,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAC"}