@venizia/dev-configs 0.2.1-0 → 0.3.0

package/README.md

@@ -1,35 +1,55 @@
 # @venizia/dev-configs
 
-The ESLint, Prettier and TypeScript settings every IGNIS package is built with. Install it as a dev
-dependency in an application that wants the same rules.
+The oxlint, oxfmt, ESLint, Prettier and TypeScript settings every IGNIS package is built with. Install
+it as a dev dependency in an application that wants the same rules.
 
 ## Install
 
 ```bash
-bun add -d @venizia/dev-configs eslint prettier typescript
+bun add -d @venizia/dev-configs oxlint oxlint-tsgolint oxfmt eslint jiti typescript
 ```
 
-`eslint` (9 or 10), `prettier` (3) and `typescript` (5 or 6) are optional peers. Install only the
-tools you use.
+`oxlint` (>=1.88.0), `oxlint-tsgolint` (>=7.0.2004), `oxfmt` (>=0.73.0), `eslint` (9 or 10),
+`jiti` (>=2.2), `prettier` (3) and `typescript` (5 or 6) are optional peers. Install only the tools
+you use. ESLint loads an `eslint.config.mts` through `jiti`, so a project with one needs it. A
+project that still runs ESLint and Prettier installs `eslint prettier` and skips the oxc tools.
 
 ## Use it
 
-Each tool takes one file.
+Each tool takes one file. IGNIS keeps them in a `.configs/` folder and passes `-c` to each tool.
 
-```javascript
-// eslint.config.mjs
-import { eslintConfigs } from '@venizia/dev-configs';
+```typescript
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import { oxlintConfigs } from '@venizia/dev-configs/linters';
+
+export default defineConfig(oxlintConfigs);
+```
 
-export default [{ ignores: ['dist/'] }, ...eslintConfigs];
+```typescript
+// .configs/oxfmt.config.mts
+import { defineConfig } from 'oxfmt';
+import { oxfmtConfigs } from '@venizia/dev-configs/formatters';
+
+export default defineConfig(oxfmtConfigs);
 ```
 
-```javascript
-// .prettierrc.mjs
-import { prettierConfigs } from '@venizia/dev-configs';
+```typescript
+// .configs/eslint.config.mts - the one rule oxlint cannot run yet
+import { namingConventionConfigs } from '@venizia/dev-configs/linters';
+
+export default namingConventionConfigs;
+```
 
-export default prettierConfigs;
+```bash
+oxlint -c .configs/oxlint.config.mts --deny-warnings
+eslint -c .configs/eslint.config.mts .
+oxfmt -c .configs/oxfmt.config.mts --check "**/*.{ts,tsx,mts,js,mjs}"
 ```
 
+`tsconfig.json` stays at the project root. Bun, the editor and oxlint's type-aware engine only find it
+there.
+
 ```json
 // tsconfig.json
 {
@@ -63,14 +83,97 @@ earlier. Every IGNIS example does.
 
 | Entry point | What it gives |
 | :--- | :--- |
-| `@venizia/dev-configs` | `eslintConfigs` (flat config array), `ReactEslintConfigs`, `prettierConfigs`, `BunCompiler` |
-| `@venizia/dev-configs/tsconfig.base.json` | Target and lib ES2024, `module` Node16, strict mode with `noImplicitAny`, `strictPropertyInitialization` and `useUnknownInCatchVariables` off, `noEmitOnError`, tests excluded |
+| `@venizia/dev-configs` | Everything below, re-exported |
+| `@venizia/dev-configs/compilers` | `BunCompiler` |
+| `@venizia/dev-configs/formatters` | `oxfmtConfigs`, `prettierConfigs` |
+| `@venizia/dev-configs/linters` | `oxlintConfigs`, `namingConventionConfigs`, `eslintConfigs`, `ReactEslintConfigs`, the rule classes and their types |
+| `@venizia/dev-configs/tsconfig.base.json` | Target and lib ES2025, `module` Node16, strict mode with `noImplicitAny`, `strictPropertyInitialization` and `useUnknownInCatchVariables` off, `noEmitOnError`, tests excluded |
 | `@venizia/dev-configs/tsconfig.common.json` | Extends the base and switches `module` and `moduleResolution` to `nodenext` |
 
 ## What each config sets
 
-`eslintConfigs` is `@minimaltech/eslint-node` (ESLint recommended, typescript-eslint, Prettier as a
-lint rule, naming conventions, `curly`, `eslint-plugin-n`) plus these IGNIS rules:
+### oxlintConfigs
+
+`oxlintConfigs` (type `OxlintConfig`) is a static port of the `eslintConfigs` rules, generated with
+`@oxlint/migrate`. It enables the `typescript` and `unicorn` plugins and type-aware linting, so it needs
+`oxlint-tsgolint`.
+
+Not ported:
+
+| Rule | Why |
+| :--- | :--- |
+| `@typescript-eslint/naming-convention` | oxlint has no equivalent yet - `namingConventionConfigs` runs it in ESLint |
+| `@typescript-eslint/prefer-optional-chain` | In oxlint's nursery |
+| `no-invalid-this` | `noImplicitThis` in `tsconfig.base.json` covers it |
+| `n/prefer-node-protocol` | Maps to `unicorn/prefer-node-protocol` |
+
+### namingConventionConfigs
+
+`namingConventionConfigs` (type `Linter.Config[]`) sets only `@typescript-eslint/naming-convention`, with
+the 15 LoopBack 4 selectors. It targets `.ts`, `.tsx`, `.mts` and `.cts`, and ignores `dist`, `build`,
+`coverage`, `*.d.ts` and plain JavaScript. ESLint does not report unused disable comments in this
+config, because oxlint owns the other rules.
+
+### Rule classes
+
+Each rule has a class with `static readonly NAME` and `static build(options)`. `build` returns the rule
+entry with the IGNIS defaults. Every `severity` defaults to `'error'`.
+
+| Class | Rule name | `build` options (default) |
+| :--- | :--- | :--- |
+| `EqeqeqRule` | `eqeqeq` | `mode`: `'always' \| 'smart'` (`'smart'`) |
+| `NoUnusedVarsRule` | `no-unused-vars` | `vars` (`'all'`), `args` (`'none'`), `ignoreRestSiblings` (`false`) |
+| `SwitchCaseBracesRule` | `unicorn/switch-case-braces` | `mode`: `'always' \| 'avoid'` (`'always'`) |
+| `NoRestrictedImportsRule` | `no-restricted-imports` | `extraPaths`: `IRestrictedImportPath[]` (none), added to `PATHS` (lodash) |
+| `NoRestrictedPropertiesRule` | `no-restricted-properties` | `extraProperties`: `IRestrictedProperty[]` (none), added to `SECURE_CONTEXT` (`crypto.randomUUID`) |
+| `PreferNullishCoalescingRule` | `typescript/prefer-nullish-coalescing` | `ignoreConditionalTests`, `ignoreMixedLogicalExpressions`, `ignoreTernaryTests` (oxlint's own defaults) |
+| `NamingConventionRule` | `@typescript-eslint/naming-convention` | `extraSelectors`: `TNamingSelector[]` (none), added after `SELECTORS` |
+
+Types: `TRuleSeverity`, `TOxlintRuleEntry`, `TNamingSelector`, `IRestrictedImportPath`.
+
+Replace a rule by key. This makes `==` an error everywhere and bans one more import:
+
+```typescript
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import {
+  EqeqeqRule,
+  NoRestrictedImportsRule,
+  oxlintConfigs,
+} from '@venizia/dev-configs/linters';
+
+export default defineConfig({
+  ...oxlintConfigs,
+  rules: {
+    ...oxlintConfigs.rules,
+    [EqeqeqRule.NAME]: EqeqeqRule.build({ mode: 'always' }),
+    [NoRestrictedImportsRule.NAME]: NoRestrictedImportsRule.build({
+      extraPaths: [{ name: 'moment', message: 'Use TemporalHelper instead.' }],
+    }),
+  },
+});
+```
+
+### oxfmtConfigs and prettierConfigs
+
+`oxfmtConfigs` (type `OxfmtConfig`) and `prettierConfigs` hold the same seven options, so the output
+matches. oxfmt differs from Prettier on long union types, which it breaks with a leading `|` per line.
+
+| Setting | Value |
+| :--- | :--- |
+| `printWidth` | `100` |
+| `tabWidth` | `2` |
+| `singleQuote` | `true` |
+| `semi` | `true` |
+| `trailingComma` | `'all'` |
+| `bracketSpacing` | `true` |
+| `arrowParens` | `'avoid'` |
+
+### eslintConfigs
+
+`eslintConfigs` keeps its shape and resolves to the same rules as before, but is now owned here instead
+of wrapping `@minimaltech/eslint-node`: ESLint recommended, typescript-eslint, Prettier as a lint
+rule, naming conventions, `curly`, `eslint-plugin-n`, plus these IGNIS rules:
 
 | Rule | Setting |
 | :--- | :--- |
@@ -79,6 +182,8 @@ lint rule, naming conventions, `curly`, `eslint-plugin-n`) plus these IGNIS rule
 | `@typescript-eslint/no-namespace` | `error` |
 | `unicorn/switch-case-braces` | `['error', 'always']` |
 
+### ReactEslintConfigs
+
 `ReactEslintConfigs.create({ plugins })` is `eslintConfigs` plus what a React frontend needs. The
 plugins come in as options, so a backend installs none of them:
 
@@ -99,13 +204,13 @@ export default [
 | :--- | :--- |
 | React correctness (`jsx-key`, `no-children-prop`, `no-deprecated`, ... - 14 rules) | `error`, `.jsx`/`.tsx` |
 | `jsx-a11y` basics (`alt-text`, `aria-props`, `aria-role`, ... - 9 rules) | `error`, `.jsx`/`.tsx` |
-| `react-hooks/rules-of-hooks` / `exhaustive-deps` | `error` / `warn`, every source file |
+| `react-hooks/rules-of-hooks` / `exhaustive-deps` | `error`, every source file |
 | `@typescript-eslint/consistent-type-imports` | `['error', { prefer: 'type-imports' }]` |
 | `naming-convention` | the base rule, plus PascalCase functions (`function App()`), `.jsx`/`.tsx` |
-| `no-floating-promises`, `no-void`, `no-invalid-this`, `no-use-before-define` | `off` - a UI fires promises from handlers and uses components above their declaration |
-| `no-explicit-any` | `warn` (the base has it `off`) |
-| `no-shadow` | `warn` |
-| `no-unused-vars` | `warn`, `_`-prefixed names ignored |
+| `no-restricted-properties` | `NoRestrictedPropertiesRule.build()` - bans `crypto.randomUUID` |
+
+Nothing in the base is relaxed: frontend code meets the backend's standard, so a floating promise, a
+`void`, a use before declaration or a shadowed name fails the lint as it does in a service.
 
 Rules the automatic JSX runtime or `tsc` already enforce (`react-in-jsx-scope`, `prop-types`,
 `jsx-no-undef`, ...) are left out.
@@ -116,17 +221,45 @@ Rules the automatic JSX runtime or `tsc` already enforce (`react-in-jsx-scope`,
 - `consistent-type-imports` keeps the default `fixStyle`; a codebase that prefers
   `inline-type-imports` sets it on top.
 
-`prettierConfigs`:
+### ReactOxlintConfigs and reactNamingConventionConfigs
 
-| Setting | Value |
-| :--- | :--- |
-| `printWidth` | `100` |
-| `tabWidth` | `2` |
-| `singleQuote` | `true` |
-| `semi` | `true` |
-| `trailingComma` | `'all'` |
-| `bracketSpacing` | `true` |
-| `arrowParens` | `'avoid'` |
+The oxlint version of the React preset. oxlint runs the React, hooks and `jsx-a11y` rules natively, so
+nothing is passed in. Pair it with `reactNamingConventionConfigs` on the ESLint side:
+
+```ts
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import { ReactOxlintConfigs } from '@venizia/dev-configs/linters';
+
+export default defineConfig(ReactOxlintConfigs.create());
+
+// .configs/eslint.config.mts
+import { reactNamingConventionConfigs } from '@venizia/dev-configs/linters';
+
+export default reactNamingConventionConfigs;
+```
+
+`ReactOxlintConfigs.create()` is `oxlintConfigs` plus the same rules as the ESLint table above, as
+strict as the base. `react/no-deprecated` is left out: oxlint has no port of it. `crypto.randomUUID`
+is banned because it exists only in a secure context (https, localhost), and is `undefined` on a
+plain-http origin or in a WebView.
+
+The presets start strict. An application that wants less overrides the rule after the preset:
+
+```ts
+const base = ReactOxlintConfigs.create();
+
+export default defineConfig({
+  ...base,
+  rules: { ...base.rules, 'typescript/no-floating-promises': 'warn' },
+});
+```
+
+`reactNamingConventionConfigs` is `namingConventionConfigs` plus PascalCase functions in `.jsx` and
+`.tsx` files. To ban `crypto.randomUUID` in a project without React, add
+`[NoRestrictedPropertiesRule.NAME]: NoRestrictedPropertiesRule.build()` to its rules.
+
+### BunCompiler
 
 `BunCompiler.compile()` builds one Bun executable: minified, with a linked source map. The
 compile target comes from `BUN_TARGET` and defaults to `bun-linux-x64`.
@@ -146,6 +279,7 @@ The root of the chain, with no IGNIS dependency: **dev-configs** -> inversion ->
 
 - [Tooling configuration](https://ignis.venizia.ai/best-practices/code-style-standards/tooling)
 - [TypeScript 6 and toolchain changelog](https://ignis.venizia.ai/changelogs/2026-03-31-typescript-6-and-toolchain)
+- [oxlint and oxfmt changelog](https://ignis.venizia.ai/changelogs/2026-10-16-oxlint-oxfmt-migration)
 - [Changelog](https://ignis.venizia.ai/changelogs/)
 - [Source](https://github.com/VENIZIA-AI/ignis/blob/main/packages/dev-configs)
 

package/dist/{compile.d.ts → compilers/bun.d.ts}

@@ -12,4 +12,4 @@ export declare class BunCompiler {
         plugins?: Bun.BunPlugin[];
     }): Promise<void>;
 }
-//# sourceMappingURL=compile.d.ts.map
+//# sourceMappingURL=bun.d.ts.map

package/dist/compilers/bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":"AAIA,gHAAgH;AAChH,qBAAa,WAAW;IACtB;;;;OAIG;WACU,OAAO,CAClB,IAAI,GAAE;QACJ,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;KACtB,GACL,OAAO,CAAC,IAAI,CAAC;CAgCjB"}

package/dist/{compile.js → compilers/bun.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BunCompiler = void 0;
-const DEFAULT_ENTRYPOINT = "./dist/index.js";
-const DEFAULT_OUTFILE = "./dist/bin";
-const DEFAULT_COMPILE_TARGET = "bun-linux-x64";
+const DEFAULT_ENTRYPOINT = './dist/index.js';
+const DEFAULT_OUTFILE = './dist/bin';
+const DEFAULT_COMPILE_TARGET = 'bun-linux-x64';
 /** Bundles and compiles a single Bun executable: minified, linked sourcemaps, target read from `BUN_TARGET`. */
 class BunCompiler {
     /**
@@ -15,12 +15,11 @@ class BunCompiler {
         const { entrypoint = DEFAULT_ENTRYPOINT, outfile = DEFAULT_OUTFILE, target = Bun.env.BUN_TARGET ?? DEFAULT_COMPILE_TARGET, plugins = [], } = opts;
         const built = await Bun.build({
             entrypoints: [entrypoint],
-            target: "bun",
+            target: 'bun',
             minify: { whitespace: true, syntax: true },
-            sourcemap: "linked",
+            sourcemap: 'linked',
             throw: false,
             compile: {
-                // `target` is read from an environment variable at runtime, so it cannot be checked against Bun's literal union at compile time.
                 target: target,
                 outfile,
             },
@@ -31,10 +30,10 @@ class BunCompiler {
             // create a circular workspace dependency, so a failed compile throws a plain `Error` instead.
             throw new Error([
                 `[BunCompiler] compile failed for entrypoint "${entrypoint}":`,
-                ...built.logs.map((log) => `[${log.level}] ${log.message}`),
-            ].join("\n"));
+                ...built.logs.map(log => `[${log.level}] ${log.message}`),
+            ].join('\n'));
         }
     }
 }
 exports.BunCompiler = BunCompiler;
-//# sourceMappingURL=compile.js.map
+//# sourceMappingURL=bun.js.map

package/dist/compilers/bun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.js","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":";;;AAAA,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAC7C,MAAM,eAAe,GAAG,YAAY,CAAC;AACrC,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAE/C,gHAAgH;AAChH,MAAa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAClB,OAKI,EAAE;QAEN,MAAM,EACJ,UAAU,GAAG,kBAAkB,EAC/B,OAAO,GAAG,eAAe,EACzB,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,UAAU,IAAI,sBAAsB,EACrD,OAAO,GAAG,EAAE,GACb,GAAG,IAAI,CAAC;QAET,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC;YAC5B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;YAC1C,SAAS,EAAE,QAAQ;YACnB,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE;gBACP,MAAM,EAAE,MAAiC;gBACzC,OAAO;aACR;YACD,OAAO;SACR,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACnB,4FAA4F;YAC5F,8FAA8F;YAC9F,MAAM,IAAI,KAAK,CACb;gBACE,gDAAgD,UAAU,IAAI;gBAC9D,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC;aAC1D,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA7CD,kCA6CC"}

package/dist/compilers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bun';
+//# sourceMappingURL=index.d.ts.map

package/dist/compilers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compilers/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC"}

package/dist/compilers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bun"), exports);
+//# sourceMappingURL=index.js.map

package/dist/compilers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/compilers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAsB"}

package/dist/formatters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './oxfmt';
+export * from './prettier';
+//# sourceMappingURL=index.d.ts.map

package/dist/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC"}

package/dist/formatters/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./oxfmt"), exports);
+__exportStar(require("./prettier"), exports);
+//# sourceMappingURL=index.js.map

package/dist/formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,6CAA2B"}

package/dist/formatters/oxfmt.d.ts

@@ -0,0 +1,14 @@
+import type { OxfmtConfig } from 'oxfmt';
+/**
+ * The oxfmt port of `prettierConfigs` - the same seven options, so the output matches Prettier's.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { oxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(oxfmtConfigs);
+ * ```
+ */
+export declare const oxfmtConfigs: OxfmtConfig;
+//# sourceMappingURL=oxfmt.d.ts.map

package/dist/formatters/oxfmt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oxfmt.d.ts","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,EAAE,WAQ1B,CAAC"}

package/dist/formatters/oxfmt.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oxfmtConfigs = void 0;
+/**
+ * The oxfmt port of `prettierConfigs` - the same seven options, so the output matches Prettier's.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { oxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(oxfmtConfigs);
+ * ```
+ */
+exports.oxfmtConfigs = {
+    bracketSpacing: true,
+    singleQuote: true,
+    printWidth: 100,
+    tabWidth: 2,
+    trailingComma: 'all',
+    arrowParens: 'avoid',
+    semi: true,
+};
+//# sourceMappingURL=oxfmt.js.map

package/dist/formatters/oxfmt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oxfmt.js","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;GAUG;AACU,QAAA,YAAY,GAAgB;IACvC,cAAc,EAAE,IAAI;IACpB,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,GAAG;IACf,QAAQ,EAAE,CAAC;IACX,aAAa,EAAE,KAAK;IACpB,WAAW,EAAE,OAAO;IACpB,IAAI,EAAE,IAAI;CACX,CAAC"}

package/dist/formatters/prettier.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'prettier';
+export declare const prettierConfigs: Config;
+//# sourceMappingURL=prettier.d.ts.map

package/dist/formatters/prettier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettier.d.ts","sourceRoot":"","sources":["../../src/formatters/prettier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,MAQ7B,CAAC"}

package/dist/{prettier.js → formatters/prettier.js}

@@ -6,8 +6,8 @@ exports.prettierConfigs = {
     singleQuote: true,
     printWidth: 100,
     tabWidth: 2,
-    trailingComma: "all",
-    arrowParens: "avoid",
+    trailingComma: 'all',
+    arrowParens: 'avoid',
     semi: true,
 };
 //# sourceMappingURL=prettier.js.map

package/dist/formatters/prettier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettier.js","sourceRoot":"","sources":["../../src/formatters/prettier.ts"],"names":[],"mappings":";;;AAEa,QAAA,eAAe,GAAW;IACrC,cAAc,EAAE,IAAI;IACpB,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,GAAG;IACf,QAAQ,EAAE,CAAC;IACX,aAAa,EAAE,KAAK;IACpB,WAAW,EAAE,OAAO;IACpB,IAAI,EAAE,IAAI;CACX,CAAC"}

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./compile";
-export * from "./eslint";
-export * from "./prettier";
-export * from "./react";
+export * from './compilers';
+export * from './formatters';
+export * from './linters';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -14,8 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./compile"), exports);
-__exportStar(require("./eslint"), exports);
-__exportStar(require("./prettier"), exports);
-__exportStar(require("./react"), exports);
+__exportStar(require("./compilers"), exports);
+__exportStar(require("./formatters"), exports);
+__exportStar(require("./linters"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,2CAAyB;AACzB,6CAA2B;AAC3B,0CAAwB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,+CAA6B;AAC7B,4CAA0B"}

package/dist/linters/eslint.d.ts

@@ -0,0 +1,20 @@
+import type { Linter } from 'eslint';
+/**
+ * The full ESLint preset, owned here: the LoopBack 4 rule set on the ESLint, typescript-eslint and
+ * Prettier recommended presets, type-aware through the project service. A project on oxlint uses
+ * `oxlintConfigs` + `namingConventionConfigs` instead.
+ */
+export declare const eslintConfigs: Linter.Config[];
+/**
+ * The one rule of `eslintConfigs` that oxlint cannot run yet, as a standalone ESLint preset to run
+ * next to `oxlintConfigs`. It needs no type information, so ESLint stays fast.
+ *
+ * ```js
+ * // .configs/eslint.config.mts
+ * import { namingConventionConfigs } from '@venizia/dev-configs/linters';
+ *
+ * export default namingConventionConfigs;
+ * ```
+ */
+export declare const namingConventionConfigs: Linter.Config[];
+//# sourceMappingURL=eslint.d.ts.map

package/dist/linters/eslint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint.d.ts","sourceRoot":"","sources":["../../src/linters/eslint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAwFrC;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAqCvC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAWlD,CAAC"}