@jsse/eslint-config 0.3.7 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @jsse/eslint-config
 
+## 0.4.0
+
+### Minor Changes
+
+- 7751e66: removed tailwind support
+
+### Patch Changes
+
+- e15fd48: re-orged several things. fixed type aware lints
+
 ## 0.3.7
 
 ### Patch Changes

package/dist/cli.js

@@ -1,6 +1,6 @@
 // src/cli.ts
-import fs from "node:fs";
-import process2 from "node:process";
+import fs from "fs";
+import process2 from "process";
 
 // node_modules/.pnpm/cac@6.7.14/node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -588,7 +588,7 @@ var CAC = class extends EventEmitter {
 var cac = (name = "") => new CAC(name);
 
 // src/generated/version.ts
-var VERSION = "0.3.7";
+var VERSION = "0.4.0";
 
 // src/cli.ts
 var cli = cac("jsselint");

package/dist/esm/config-fns.d.ts

@@ -1,40 +1,116 @@
 import { reactHooks } from "./configs/react.js";
-export declare function configFunctions(): {
-    antfu: import("./types.js").EslintConfigFn<{
-        topLevelFunction: "error" | "off";
-    }>;
-    command: import("./types.js").EslintConfigFn;
-    comments: import("./types.js").EslintConfigFn;
-    ignores: import("./types.js").EslintConfigFn;
-    imports: import("./types.js").EslintConfigFn<import("./types.js").OptionsStylistic>;
-    javascript: import("./types.js").EslintConfigFn<import("./types.js").OptionsIsInEditor & import("./types.js").OptionsOverrides & {
-        reportUnusedDisableDirectives?: boolean;
-    }>;
-    jsdoc: import("./types.js").EslintConfigFn;
-    jsonc: import("./types.js").EslintConfigFn<import("./types.js").OptionsStylistic & import("./types.js").OptionsOverrides>;
-    markdown: import("./types.js").EslintConfigFn<import("./types.js").OptionsComponentExts & import("./types.js").OptionsOverrides>;
-    n: import("./types.js").EslintConfigFn;
-    noOnlyTests: import("./types.js").EslintConfigFn<import("./types.js").OptionsIsInEditor & import("./types.js").OptionsOverrides>;
-    perfectionist: import("./types.js").EslintConfigFn;
-    prettier: import("./types.js").EslintConfigFn;
-    react: import("./types.js").EslintConfigFn<import("./types.js").OptionsComponentExts & import("./types.js").OptionsOverrides & import("./types.js").OptionsTypeScriptWithTypes & import("./types.js").OptionsTypeScriptParserOptions & import("./types.js").OptionsReact>;
-    reactHooks: typeof reactHooks;
-    sortPackageJson: import("./types.js").EslintConfigFn;
-    sortTsconfig: import("./types.js").EslintConfigFn<{
-        extendTsconfigGlobs?: string[];
-    }>;
-    stylistic: import("./types.js").EslintConfigFn<import("./types.js").StylisticConfig>;
-    tailwind: import("./types.js").EslintConfigFn<Partial<import("./types.js").TailwindEslintSettings>>;
-    toml: import("./types.js").EslintConfigFn<import("./types.js").OptionsOverrides & import("./types.js").OptionsFiles & import("./types.js").OptionsStylistic>;
-    tsdoc: import("./types.js").EslintConfigFn;
-    typescript: import("./types.js").EslintConfigFn<import("./types.js").OptionsComponentExts & import("./types.js").OptionsOverrides & import("./types.js").OptionsTypeScriptWithTypes & import("./types.js").OptionsTypeScriptParserOptions & import("./types.js").OptionsReact & import("./types.js").OptionsPrefix>;
-    unicorn: import("./types.js").EslintConfigFn;
-    vitest: import("./types.js").EslintConfigFn<import("./types.js").OptionsIsInEditor & import("./types.js").OptionsOverrides>;
-    yml: import("./types.js").EslintConfigFn<import("./types.js").OptionsOverrides & import("./types.js").OptionsStylistic & import("./types.js").OptionsFiles>;
+export declare const CONFIGS_MAPPING: {
+    antfu: {
+        fn: import("./types.js").EslintConfigFn<{
+            topLevelFunction: "error" | "off";
+        }>;
+        typeName: string;
+    };
+    command: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    "de-morgan": {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    "eslint-comments": {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    ignores: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    imports: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsStylistic>;
+        typeName: string;
+    };
+    javascript: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsIsInEditor & import("./types.js").OptionsOverrides & {
+            reportUnusedDisableDirectives?: boolean;
+        }>;
+        typeName: string;
+    };
+    jsdoc: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    jsonc: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsStylistic & import("./types.js").OptionsOverrides>;
+        typeName: string;
+    };
+    markdown: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsComponentExts & import("./types.js").OptionsOverrides>;
+        typeName: string;
+    };
+    n: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    "no-only-tests": {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsIsInEditor & import("./types.js").OptionsOverrides>;
+        typeName: string;
+    };
+    perfectionist: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    prettier: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    react: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsComponentExts & import("./types.js").OptionsOverrides & import("./types.js").OptionsTypeScriptWithTypes & import("./types.js").OptionsTypeScriptParserOptions & import("./types.js").OptionsReact>;
+        typeName: string;
+    };
+    "react-hooks": {
+        fn: typeof reactHooks;
+        typeName: string;
+    };
+    "sort-package-json": {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    "sort-tsconfig": {
+        fn: import("./types.js").EslintConfigFn<{
+            extendTsconfigGlobs?: string[];
+        }>;
+        typeName: string;
+    };
+    stylistic: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").StylisticConfig>;
+        typeName: string;
+    };
+    toml: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsOverrides & import("./types.js").OptionsFiles & import("./types.js").OptionsStylistic>;
+        typeName: string;
+    };
+    tsdoc: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    typescript: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsComponentExts & import("./types.js").OptionsOverrides & import("./types.js").OptionsTypeScriptWithTypes & import("./types.js").OptionsTypeScriptParserOptions & import("./types.js").OptionsReact & import("./types.js").OptionsPrefix>;
+        typeName: string;
+    };
+    unicorn: {
+        fn: import("./types.js").EslintConfigFn;
+        typeName: string;
+    };
+    vitest: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsIsInEditor & import("./types.js").OptionsOverrides>;
+        typeName: string;
+    };
+    yml: {
+        fn: import("./types.js").EslintConfigFn<import("./types.js").OptionsOverrides & import("./types.js").OptionsStylistic & import("./types.js").OptionsFiles>;
+        typeName: string;
+    };
 };
 export { antfu } from "./configs/antfu.js";
 export { command } from "./configs/command.js";
-export { comments } from "./configs/comments.js";
+export { deMorgan } from "./configs/de-morgan.js";
+export { eslintComments } from "./configs/eslint-comments.js";
 export { ignores } from "./configs/ignores.js";
 export { imports } from "./configs/imports.js";
 export { javascript } from "./configs/javascript.js";
@@ -49,7 +125,6 @@ export { react, reactHooks } from "./configs/react.js";
 export { sortPackageJson } from "./configs/sort-package-json.js";
 export { sortTsconfig } from "./configs/sort-tsconfig.js";
 export { stylistic } from "./configs/stylistic.js";
-export { tailwind } from "./configs/tailwind.js";
 export { toml } from "./configs/toml.js";
 export { typescript } from "./configs/ts/typescript.js";
 export { tsdoc } from "./configs/tsdoc.js";

package/dist/esm/config-fns.js

@@ -1,6 +1,7 @@
 import { antfu } from "./configs/antfu.js";
 import { command } from "./configs/command.js";
-import { comments } from "./configs/comments.js";
+import { deMorgan } from "./configs/de-morgan.js";
+import { eslintComments } from "./configs/eslint-comments.js";
 import { ignores } from "./configs/ignores.js";
 import { imports } from "./configs/imports.js";
 import { javascript } from "./configs/javascript.js";
@@ -15,47 +16,123 @@ import { react, reactHooks } from "./configs/react.js";
 import { sortPackageJson } from "./configs/sort-package-json.js";
 import { sortTsconfig } from "./configs/sort-tsconfig.js";
 import { stylistic } from "./configs/stylistic.js";
-import { tailwind } from "./configs/tailwind.js";
 import { toml } from "./configs/toml.js";
 import { typescript } from "./configs/ts/typescript.js";
 import { tsdoc } from "./configs/tsdoc.js";
 import { unicorn } from "./configs/unicorn.js";
 import { vitest } from "./configs/vitest.js";
 import { yml } from "./configs/yml.js";
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function configFunctions() {
-    // @keep-sorted
-    return {
-        antfu,
-        command,
-        comments,
-        ignores,
-        imports,
-        javascript,
-        jsdoc,
-        jsonc,
-        markdown,
-        n,
-        noOnlyTests,
-        perfectionist,
-        prettier,
-        react,
-        reactHooks,
-        sortPackageJson,
-        sortTsconfig,
-        stylistic,
-        tailwind,
-        toml,
-        tsdoc,
-        typescript,
-        unicorn,
-        vitest,
-        yml,
-    };
-}
+export const CONFIGS_MAPPING = {
+    antfu: {
+        fn: antfu,
+        typeName: "AntfuRuleOptions",
+    },
+    command: {
+        fn: command,
+        typeName: "CommandRuleOptions",
+    },
+    "de-morgan": {
+        fn: deMorgan,
+        typeName: "DeMorganRuleOptions",
+    },
+    "eslint-comments": {
+        fn: eslintComments,
+        typeName: "EslintCommentsRuleOptions",
+    },
+    ignores: {
+        fn: ignores,
+        typeName: "IgnoresRuleOptions",
+    },
+    imports: {
+        fn: imports,
+        typeName: "ImportsRuleOptions",
+    },
+    javascript: {
+        fn: javascript,
+        typeName: "JavascriptRuleOptions",
+    },
+    jsdoc: {
+        fn: jsdoc,
+        typeName: "JsdocRuleOptions",
+    },
+    jsonc: {
+        fn: jsonc,
+        typeName: "JsoncRuleOptions",
+    },
+    markdown: {
+        fn: markdown,
+        typeName: "MarkdownRuleOptions",
+    },
+    n: {
+        fn: n,
+        typeName: "NRuleOptions",
+    },
+    "no-only-tests": {
+        fn: noOnlyTests,
+        typeName: "NoOnlyTestsRuleOptions",
+    },
+    perfectionist: {
+        fn: perfectionist,
+        typeName: "PerfectionistRuleOptions",
+    },
+    prettier: {
+        fn: prettier,
+        typeName: "PrettierRuleOptions",
+    },
+    react: {
+        fn: react,
+        typeName: "ReactRuleOptions",
+    },
+    "react-hooks": {
+        fn: reactHooks,
+        typeName: "ReactHooksRuleOptions",
+    },
+    "sort-package-json": {
+        fn: sortPackageJson,
+        typeName: "SortPackageJsonRuleOptions",
+    },
+    "sort-tsconfig": {
+        fn: sortTsconfig,
+        typeName: "SortTsconfigRuleOptions",
+    },
+    stylistic: {
+        fn: stylistic,
+        typeName: "StylisticRuleOptions",
+    },
+    toml: {
+        fn: toml,
+        typeName: "TomlRuleOptions",
+    },
+    tsdoc: {
+        fn: tsdoc,
+        typeName: "TsdocRuleOptions",
+    },
+    // deprecated
+    // tailwind: {
+    //   typeName: "TailwindRuleOptions",
+    //   fn: tailwind,
+    // },
+    typescript: {
+        fn: typescript,
+        typeName: "TypescriptRuleOptions",
+    },
+    unicorn: {
+        fn: unicorn,
+        typeName: "UnicornRuleOptions",
+    },
+    vitest: {
+        fn: vitest,
+        typeName: "VitestRuleOptions",
+    },
+    yml: {
+        fn: yml,
+        typeName: "YmlRuleOptions",
+    },
+};
 export { antfu } from "./configs/antfu.js";
 export { command } from "./configs/command.js";
-export { comments } from "./configs/comments.js";
+export { deMorgan } from "./configs/de-morgan.js";
+export { eslintComments } from "./configs/eslint-comments.js";
 export { ignores } from "./configs/ignores.js";
 export { imports } from "./configs/imports.js";
 export { javascript } from "./configs/javascript.js";
@@ -70,7 +147,6 @@ export { react, reactHooks } from "./configs/react.js";
 export { sortPackageJson } from "./configs/sort-package-json.js";
 export { sortTsconfig } from "./configs/sort-tsconfig.js";
 export { stylistic } from "./configs/stylistic.js";
-export { tailwind } from "./configs/tailwind.js";
 export { toml } from "./configs/toml.js";
 export { typescript } from "./configs/ts/typescript.js";
 export { tsdoc } from "./configs/tsdoc.js";

package/dist/esm/configs/{comments.d.ts → de-morgan.d.ts}

@@ -1,2 +1,2 @@
 import type { EslintConfigFn } from "../types.js";
-export declare const comments: EslintConfigFn;
+export declare const deMorgan: EslintConfigFn;

package/dist/esm/configs/de-morgan.js

@@ -0,0 +1,9 @@
+import { pluginDeMorgan } from "../plugins.js";
+export const deMorgan = async () => {
+    return [
+        {
+            ...pluginDeMorgan.configs.recommended,
+            name: "jsse/de-morgan",
+        },
+    ];
+};

package/dist/esm/configs/eslint-comments.d.ts

@@ -0,0 +1,2 @@
+import type { EslintConfigFn } from "../types.js";
+export declare const eslintComments: EslintConfigFn;

package/dist/esm/configs/{comments.js → eslint-comments.js}

@@ -1,5 +1,5 @@
 import { pluginEslintComments } from "../plugins.js";
-export const comments = async () => [
+export const eslintComments = async () => [
     {
         name: "jsse/eslint-comments",
         plugins: {

package/dist/esm/configs/gql.d.ts

@@ -1,2 +1,2 @@
-import type { TypedFlatConfigItem } from "src/types.js";
-export declare function gql(): TypedFlatConfigItem[];
+import type { Config } from "src/types.js";
+export declare function gql(): Config[];

package/dist/esm/configs/markdown.js

@@ -18,7 +18,7 @@ export const markdown = async (options) => {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         pluginMarkdown.processors.markdown,
         processorPassThrough,
-    ].filter((processor) => processor !== undefined));
+    ]);
     return [
         {
             name: "jsse/markdown/setup",

package/dist/esm/configs/prettier.d.ts

@@ -1,7 +1,7 @@
-import type { EslintConfigFn, TypedFlatConfigItem } from "../types.js";
+import type { Config, EslintConfigFn } from "../types.js";
 /**
  * Copied from https://raw.githubusercontent.com/prettier/eslint-config-prettier/main/index.js
  * Main difference is we exclude rules we don't care about.... (flow/babel/etc)
  */
-export declare function eslintConfigPrettierRules(): TypedFlatConfigItem["rules"];
+export declare function eslintConfigPrettierRules(): Config["rules"];
 export declare const prettier: EslintConfigFn;

package/dist/esm/configs/react.d.ts

@@ -1,6 +1,6 @@
-import type { EslintConfigFn, OptionsComponentExts, OptionsOverrides, OptionsReact, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes, TypedFlatConfigItem } from "../types.js";
-export declare function reactRules(): TypedFlatConfigItem["rules"];
-export declare function reactHooks(): Promise<TypedFlatConfigItem[]>;
+import type { Config, EslintConfigFn, OptionsComponentExts, OptionsOverrides, OptionsReact, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes } from "../types.js";
+export declare function reactRules(): Config["rules"];
+export declare function reactHooks(): Promise<Config[]>;
 type ReactOptions = OptionsComponentExts & OptionsOverrides & OptionsTypeScriptWithTypes & OptionsTypeScriptParserOptions & OptionsReact;
 export declare const react: EslintConfigFn<ReactOptions>;
 export {};

package/dist/esm/configs/stylistic.js

@@ -1,5 +1,5 @@
 import { importPluginStylistic } from "../plugins.js";
-function jsxStylistic({ indent, }) {
+function jsxStylistic({ indent }) {
     return {
         "@stylistic/jsx-curly-brace-presence": [
             "error",

package/dist/esm/configs/ts/parser.d.ts

@@ -1,7 +1,7 @@
-import type { OptionsComponentExts, OptionsReact, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes, TypedFlatConfigItem } from "../../types.js";
+import type { Config, OptionsComponentExts, OptionsReact, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes } from "../../types.js";
 export type TsParserOptions = OptionsComponentExts & OptionsTypeScriptParserOptions & OptionsTypeScriptWithTypes & OptionsReact & {
     name?: string;
 };
-export declare function typescriptParser(options: TsParserOptions): TypedFlatConfigItem & {
+export declare function typescriptParser(options: TsParserOptions): Config & {
     name: string;
 };

package/dist/esm/configs/ts/parser.js

@@ -1,5 +1,5 @@
 import process from "node:process";
-import { debug } from "src/lager.js";
+import { dbg } from "src/lager.js";
 import { GLOB_MARKDOWN, GLOB_TS, GLOB_TSX } from "../../globs.js";
 import { parserTs } from "../../plugins.js";
 function autoUseParserService(options) {
@@ -17,12 +17,13 @@ export function typescriptParser(options) {
     const { componentExts = [], filesTypeAware: files = [GLOB_TS, GLOB_TSX], ignoresTypeAware: ignores = [GLOB_MARKDOWN], name, parserOptions: parserOptionsOverride = {}, react, tsconfig, useProjectService = autoUseParserService(options), } = options;
     const typeAware = !!tsconfig;
     if (useProjectService) {
-        debug("ts parser-options using `projectService`project service");
+        dbg("ts parser-options using `projectService`project service");
         return {
             files,
-            ...(ignores ? { ignores } : {}),
+            ...(ignores.length > 0 ? { ignores } : {}),
             languageOptions: {
                 parser: parserTs,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 parserOptions: {
                     extraFileExtensions: componentExts.map((ext) => `.${ext}`),
                     jsxPragma: react ? "React" : undefined,
@@ -44,12 +45,13 @@ export function typescriptParser(options) {
             name: name ?? `jsse/typescript/${typeAware ? "type-aware-parser" : "parser"}`,
         };
     }
-    debug("ts parser-options NOT using `projectService`project service - using `project`");
+    dbg("ts parser-options NOT using `projectService`project service - using `project`");
     return {
         files,
-        ...(ignores ? { ignores } : {}),
+        ...(ignores.length > 0 ? { ignores } : {}),
         languageOptions: {
             parser: parserTs,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             parserOptions: {
                 extraFileExtensions: componentExts.map((ext) => `.${ext}`),
                 jsxPragma: react ? "React" : undefined,

package/dist/esm/configs/ts/typescript-rules.d.ts

@@ -1,6 +1,11 @@
-import type { TypedFlatConfigItem } from "../../types.js";
-export declare function typescriptRulesTypeAware(): TypedFlatConfigItem["rules"];
-export declare function typescriptRulesTypeOblivious(): TypedFlatConfigItem["rules"];
+import type { Config } from "../../types.js";
+export declare function typescriptRulesTypeAware(props?: {
+    strict?: boolean;
+}): Config["rules"];
+export declare function typescriptRulesTypeOblivious(props?: {
+    strict?: boolean;
+}): Config["rules"];
 export declare function typescriptRules(props?: {
     typeAware: boolean;
-}): TypedFlatConfigItem["rules"];
+    strict: boolean;
+}): Config["rules"];

package/dist/esm/configs/ts/typescript-rules.js

@@ -1,5 +1,19 @@
-export function typescriptRulesTypeAware() {
+/* eslint-disable perfectionist/sort-objects */
+import tseslint, {} from "typescript-eslint";
+import { dbg } from "../../lager.js";
+const extractRules = (configs) => {
+    const rules = configs
+        .filter((config) => config.rules !== undefined)
+        .map((config) => config.rules ?? {});
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return Object.assign({}, ...rules);
+};
+export function typescriptRulesTypeAware(props) {
+    const tsRecomendedRulesTypeChecked = props?.strict
+        ? extractRules(tseslint.configs.strictTypeChecked)
+        : extractRules(tseslint.configs.recommendedTypeChecked);
     return {
+        ...tsRecomendedRulesTypeChecked,
         "@typescript-eslint/await-thenable": "error",
         "@typescript-eslint/no-for-in-array": "error",
         "no-implied-eval": "off",
@@ -116,8 +130,12 @@ export function typescriptRulesTypeAware() {
         ],
     };
 }
-export function typescriptRulesTypeOblivious() {
+export function typescriptRulesTypeOblivious(props) {
+    const tseslintBaseRules = props?.strict
+        ? extractRules(tseslint.configs.strict)
+        : extractRules(tseslint.configs.recommended);
     return {
+        ...tseslintBaseRules,
         eqeqeq: "error",
         camelcase: "off",
         yoda: "error",
@@ -140,61 +158,6 @@ export function typescriptRulesTypeOblivious() {
             },
         ],
         "@typescript-eslint/adjacent-overload-signatures": "error",
-        // "@typescript-eslint/ban-types": [
-        //   "warn",
-        //   {
-        //     extendDefaults: false,
-        //     types: {
-        //       String: {
-        //         message: 'Use "string" instead',
-        //         fixWith: "string",
-        //       },
-        //       Boolean: {
-        //         message: 'Use "boolean" instead',
-        //         fixWith: "boolean",
-        //       },
-        //       Number: {
-        //         message: 'Use "number" instead',
-        //         fixWith: "number",
-        //       },
-        //       BigInt: {
-        //         message: "Use `bigint` instead.",
-        //         fixWith: "bigint",
-        //       },
-        //       Object: {
-        //         message:
-        //           "The `Object` type is mostly the same as `unknown`. You probably want `Record<string, unknown>` instead. See https://github.com/typescript-eslint/typescript-eslint/pull/848",
-        //         fixWith: "Record<string, unknown>",
-        //       },
-        //       object: {
-        //         message:
-        //           "The `object` type is hard to use. Use `Record<string, unknown>` instead. See: https://github.com/typescript-eslint/typescript-eslint/pull/848",
-        //         fixWith: "Record<string, unknown>",
-        //       },
-        //       Symbol: {
-        //         message: 'Use "symbol" instead',
-        //         fixWith: "symbol",
-        //       },
-        //       Function: {
-        //         message:
-        //           'The "Function" type accepts any function-like value.\nIt provides no type safety when calling the function, which can be a common source of bugs.\nIt also accepts things like class declarations, which will throw at runtime as they will not be called with "new".\nIf you are expecting the function to accept certain arguments, you should explicitly define the function shape.',
-        //       },
-        //       // eslint-disable-next-line @typescript-eslint/naming-convention
-        //       "{}": {
-        //         message:
-        //           "The `{}` type is mostly the same as `unknown`. You probably want `Record<string, unknown>` instead.",
-        //         fixWith: "Record<string, unknown>",
-        //       },
-        //       // eslint-disable-next-line @typescript-eslint/naming-convention
-        //       "[]": "Don't use the empty array type `[]`. It only allows empty arrays. Use `SomeType[]` instead.",
-        //       // eslint-disable-next-line @typescript-eslint/naming-convention
-        //       "[[]]":
-        //         "Don't use `[[]]`. It only allows an array with a single element which is an empty array. Use `SomeType[][]` instead.",
-        //       // eslint-disable-next-line @typescript-eslint/naming-convention
-        //       "[[[]]]": "Don't use `[[[]]]`. Use `SomeType[][][]` instead.",
-        //     },
-        //   },
-        // ],
         "@typescript-eslint/consistent-type-assertions": "error",
         "@typescript-eslint/consistent-type-definitions": ["error", "type"],
         "@typescript-eslint/member-ordering": [
@@ -404,12 +367,13 @@ export function typescriptRulesTypeOblivious() {
     };
 }
 export function typescriptRules(props) {
-    const { typeAware } = props ?? {};
-    if (typeAware === true) {
+    const normalized = { typeAware: false, strict: false, ...props };
+    dbg("building typescript rules: %O", normalized);
+    if (normalized.typeAware) {
         return {
-            ...typescriptRulesTypeOblivious(),
-            ...typescriptRulesTypeAware(),
+            ...typescriptRulesTypeOblivious({ strict: normalized.strict }),
+            ...typescriptRulesTypeAware({ strict: normalized.strict }),
         };
     }
-    return typescriptRulesTypeOblivious();
+    return typescriptRulesTypeOblivious({ strict: normalized.strict });
 }