@oxiul/configs 0.0.0-stage → 0.3.2

package/README.md

@@ -1,3 +1,16 @@
-# Temporary Holding Version
+# Configs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+## Lint config
+
+A shared config for oxlint
+
+## Format config
+
+A shared config for oxfmt
+
+## Development
+
+### Prerequisites
+
+- Node.js (from `engines.node` field in `package.json`)
+- Bun (from `packageManager` field in `package.json`)

package/dist/common-B9SE4GL9.mjs

@@ -0,0 +1,11 @@
+//#region src/common.ts
+const baseIgnorePatterns = [
+	".history/",
+	"bun.lock",
+	"**/*.gen.ts"
+];
+const arraify = (input) => input === void 0 ? [] : Array.isArray(input) ? input : [input];
+const moduleName = "oxiul";
+const packageName = "@oxiul/configs";
+//#endregion
+export { packageName as i, baseIgnorePatterns as n, moduleName as r, arraify as t };

package/dist/hook/install.d.mts

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

package/dist/hook/install.mjs

@@ -0,0 +1,37 @@
+import { i as packageName } from "../common-B9SE4GL9.mjs";
+import { exec } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+//#region src/hook/install.ts
+const promisifiedExec = promisify(exec);
+const { stdout: rawGitRepositoryRoot } = await promisifiedExec("git rev-parse --show-toplevel");
+const gitRepositoryRoot = rawGitRepositoryRoot.trim();
+const { stdout: rawHooksDirectory } = await promisifiedExec("git rev-parse --path-format=absolute --git-path hooks");
+const hooksDirectory = rawHooksDirectory.trim();
+const packageJson = await fs.readFile(path.join(gitRepositoryRoot, "package.json"), "utf8");
+const { name } = JSON.parse(packageJson);
+const HOOK_CONTENT = ["#!/bin/bash", `node ${name === "@oxiul/configs" ? "." : `./node_modules/${packageName}`}/dist/hook/pre-commit.mjs`].join("\n");
+await fs.mkdir(hooksDirectory, { recursive: true });
+const preCommitPath = path.join(hooksDirectory, "pre-commit");
+let oldHook = "";
+if (await fs.stat(preCommitPath).then(() => true).catch(() => false)) {
+	if ((await fs.lstat(preCommitPath)).isSymbolicLink()) {
+		console.log("Detected an existing git pre-commit hook");
+		await fs.unlink(preCommitPath);
+	} else {
+		oldHook = await fs.readFile(preCommitPath, "utf8");
+		if (oldHook !== HOOK_CONTENT) {
+			console.log(`Found hooks path: "${hooksDirectory}"`);
+			console.log("Detected an existing git pre-commit hook");
+			await fs.writeFile(`${preCommitPath}.old`, oldHook);
+		}
+	}
+}
+if (oldHook !== HOOK_CONTENT) {
+	console.log(`Found hooks path: "${hooksDirectory}"`);
+	await fs.writeFile(preCommitPath, HOOK_CONTENT, { mode: 493 });
+	console.log("Hook saved");
+}
+//#endregion
+export {};

package/dist/hook/pre-commit.d.mts

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

package/dist/hook/pre-commit.mjs

@@ -0,0 +1,57 @@
+import { r as moduleName } from "../common-B9SE4GL9.mjs";
+import { t as configSchema } from "../schema-DM8wm8HH.mjs";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { cosmiconfig } from "cosmiconfig";
+import { Listr } from "listr2";
+//#region src/hook/pre-commit.ts
+const failedOutputs = /* @__PURE__ */ new Map();
+const run = (command, task) => new Promise((resolve, reject) => {
+	const child = spawn(command, {
+		env: {
+			...process.env,
+			FORCE_COLOR: "1"
+		},
+		shell: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const window = task.stdout();
+	let output = "";
+	const onData = (chunk) => {
+		output += chunk;
+		window.write(chunk);
+	};
+	child.stdout.on("data", onData);
+	child.stderr.on("data", onData);
+	child.on("error", reject);
+	child.on("close", (code, signal) => {
+		if (code === 0) return resolve();
+		failedOutputs.set(command, output);
+		reject(/* @__PURE__ */ new Error(signal ? `killed by ${signal}` : `exited with code ${code}`));
+	});
+});
+const rawConfig = await cosmiconfig(moduleName).search();
+const parsedConfig = z.safeParse(configSchema, rawConfig?.config);
+if (!parsedConfig.success) throw new Error(`Validation error: ${parsedConfig.error.message}`);
+try {
+	const config = parsedConfig.data;
+	if (config.preCommitCommands && config.preCommitCommands.length !== 0) await new Listr(config.preCommitCommands.map((command) => ({
+		rendererOptions: {
+			outputBar: 5,
+			persistentOutput: false
+		},
+		task: (_ctx, task) => run(command, task),
+		title: command
+	})), { concurrent: false }).run();
+	else console.log(`No commands in pre-commit list found`);
+} catch {
+	for (const [command, output] of failedOutputs) console.error(`\n✖ Output of "${command}"\n${output}`);
+	console.error(`${failedOutputs.size} tasks failed: ${[...failedOutputs.keys()].join(", ")}`);
+	process.exit(1);
+}
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import { OxlintConfig } from "oxlint";
+import { OxfmtConfig } from "oxfmt";
+import { KnipConfig } from "knip";
+//#region src/oxlint.d.ts
+export declare const disabledRules: OxlintConfig["rules"];
+export declare const overridenRules: OxlintConfig["rules"];
+type MergableConfig$1 = Omit<OxlintConfig, "plugins"> & {
+  plugins?: Partial<Record<NonNullable<OxlintConfig["plugins"]>[number], boolean>>;
+};
+type TailwindConfig = {
+  entryPoint: string;
+};
+type VitestConfig = {
+  files?: string[];
+};
+type TanstackRouterConfig = {
+  routes: string[];
+};
+type PackageJsonConfig = boolean;
+type PlaywrightConfig = {
+  files: string[];
+  assertFunctionNames?: string[];
+};
+type ServerSideConfig = {
+  files: string[];
+  allowConsole?: string[];
+  allowProcess?: string[];
+};
+type RestrictedSyntaxRule = {
+  selector: string;
+  message: string;
+};
+type RestrictedSyntaxOverride = {
+  files: string[];
+  rules: RestrictedSyntaxRule[];
+};
+type RestrictedSyntaxConfig = {
+  banBarrelImport?: boolean;
+  banReactMemo?: boolean;
+  overrides?: RestrictedSyntaxOverride[];
+  rulesOverrides?: RestrictedSyntaxRule[];
+  previousRules?: RestrictedSyntaxRule[];
+  previousOverrides?: RestrictedSyntaxOverride[];
+};
+type RestrictedConfig = {
+  globals?: {
+    name: string;
+    message: string;
+  }[];
+  properties?: {
+    object: string;
+    property: string;
+    message: string;
+  }[];
+  syntaxOverrides?: RestrictedSyntaxConfig["overrides"];
+  syntaxRulesOverrides?: RestrictedSyntaxConfig["rulesOverrides"];
+};
+type ReactConfig = {
+  allowedStrings?: string[];
+  additionalHooks?: string[];
+  banMemo?: boolean;
+};
+type I18nConfig = {
+  ignore?: string[] | true;
+};
+type ImportConfig = {
+  allowDefault?: string[];
+  banBarrel?: boolean;
+};
+type ConfigOptions$2 = {
+  jsPlugins?: Exclude<OxlintConfig["jsPlugins"], null>;
+  plugins?: MergableConfig$1["plugins"];
+  tailwind?: TailwindConfig;
+  vitest?: VitestConfig;
+  tanstackRouter?: TanstackRouterConfig;
+  packageJson?: PackageJsonConfig;
+  playwright?: PlaywrightConfig;
+  serverSide?: ServerSideConfig;
+  restricted?: RestrictedConfig;
+  react?: ReactConfig;
+  i18n?: I18nConfig;
+  import?: ImportConfig;
+} & Pick<OxlintConfig, "env" | "rules" | "options" | "ignorePatterns" | "categories" | "settings" | "overrides" | "globals"> & ReactConfig;
+declare const getConfig$2: ({ tailwind, tanstackRouter, vitest, packageJson, playwright, serverSide, restricted, react, i18n, import: importOptions, ...config }?: ConfigOptions$2) => Promise<OxlintConfig>;
+//#endregion
+//#region src/oxfmt.d.ts
+type ConfigOptions$1 = OxfmtConfig & {
+  tailwind?: {
+    stylesheet: string;
+    functions?: string[];
+  };
+  imports?: Exclude<OxfmtConfig["sortImports"], boolean>;
+};
+declare const getConfig: ({ ignorePatterns, tailwind, imports, sortImports, ...rest }?: ConfigOptions$1) => Promise<{
+  readonly arrowParens?: import("oxfmt").ArrowParensConfig;
+  readonly associations?: import("oxfmt").OxfmtAssociationConfig[];
+  astro: import("oxfmt").AstroUserConfig;
+  readonly bracketSameLine?: boolean;
+  readonly bracketSpacing?: boolean;
+  readonly embeddedLanguageFormatting?: import("oxfmt").EmbeddedLanguageFormattingConfig;
+  readonly endOfLine?: import("oxfmt").EndOfLineConfig;
+  readonly experimentalOperatorPosition?: import("oxfmt").OperatorPositionConfig;
+  readonly htmlWhitespaceSensitivity?: import("oxfmt").HtmlWhitespaceSensitivityConfig;
+  readonly insertFinalNewline?: boolean;
+  readonly jsdoc?: import("oxfmt").JsdocUserConfig;
+  readonly jsxSingleQuote?: boolean;
+  readonly objectWrap?: import("oxfmt").ObjectWrapConfig;
+  readonly overrides?: import("oxfmt").OxfmtOverrideConfig[];
+  printWidth: number;
+  readonly proseWrap?: import("oxfmt").ProseWrapConfig;
+  readonly quoteProps?: import("oxfmt").QuotePropsConfig;
+  readonly semi?: boolean;
+  readonly singleAttributePerLine?: boolean;
+  readonly singleQuote?: boolean;
+  sortPackageJson: boolean | import("oxfmt").SortPackageJsonConfig | {
+    readonly sortScripts: true;
+  };
+  sortTailwindcss: import("oxfmt").SortTailwindcssUserConfig;
+  readonly svelte?: import("oxfmt").SvelteUserConfig;
+  readonly tabWidth?: number;
+  readonly trailingComma?: import("oxfmt").TrailingCommaConfig;
+  useTabs: boolean;
+  readonly vueIndentScriptAndStyle?: boolean;
+  readonly ignorePatterns: string[];
+  readonly sortImports: import("oxfmt").SortImportsUserConfig;
+}>;
+//#endregion
+//#region src/knip.d.ts
+type KnipConfig$1 = Exclude<KnipConfig, Function>;
+type MergableConfig = Omit<KnipConfig$1, "include"> & {
+  include?: Partial<Record<NonNullable<KnipConfig$1["include"]>[number], boolean>>;
+};
+type BaseOptions = {
+  vitest?: boolean;
+  reactNative?: boolean;
+  opencode?: boolean;
+  eslint?: boolean;
+  workspaces?: boolean;
+};
+type ConfigOptions = {
+  options?: BaseOptions;
+} & MergableConfig;
+declare const getConfig$1: ({ options, ...overrides }?: ConfigOptions) => Promise<KnipConfig$1>;
+//#endregion
+//#region src/config/schema.d.ts
+export declare const configSchema: z.ZodObject<{
+  preCommitCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type Config = z.infer<typeof configSchema>;
+//#endregion
+export { type Config, getConfig as getFormatConfig, getConfig$1 as getKnipConfig, getConfig$2 as getLintConfig };

package/dist/index.mjs

@@ -0,0 +1,472 @@
+import { n as baseIgnorePatterns, t as arraify } from "./common-B9SE4GL9.mjs";
+import { t as configSchema } from "./schema-DM8wm8HH.mjs";
+import { isNonNullish, mapValues, omitBy } from "remeda";
+//#region src/oxlint.ts
+const disabledRules = {
+	"eslint/capitalized-comments": "off",
+	"eslint/default-case": "off",
+	"eslint/id-length": "off",
+	"eslint/max-lines": "off",
+	"eslint/max-lines-per-function": "off",
+	"eslint/max-params": "off",
+	"eslint/max-statements": "off",
+	"eslint/no-await-in-loop": "off",
+	"eslint/no-continue": "off",
+	"eslint/no-duplicate-imports": "off",
+	"eslint/no-inline-comments": "off",
+	"eslint/no-nested-ternary": "off",
+	"eslint/no-ternary": "off",
+	"eslint/no-undefined": "off",
+	"eslint/no-warning-comments": "off",
+	"eslint/one-var": "off",
+	"eslint/require-await": "off",
+	"import/exports-last": "off",
+	"import/group-exports": "off",
+	"import/max-dependencies": "off",
+	"import/no-named-export": "off",
+	"import/no-namespace": "off",
+	"import/no-unassigned-import": "off",
+	"import/prefer-default-export": "off",
+	"import/unambiguous": "off",
+	"oxc/no-accumulating-spread": "off",
+	"oxc/no-async-await": "off",
+	"oxc/no-map-spread": "off",
+	"oxc/no-optional-chaining": "off",
+	"oxc/no-rest-spread-properties": "off",
+	"promise/avoid-new": "off",
+	"promise/prefer-await-to-callbacks": "off",
+	"promise/prefer-await-to-then": "off",
+	"react-perf/jsx-no-jsx-as-prop": "off",
+	"react-perf/jsx-no-new-array-as-prop": "off",
+	"react-perf/jsx-no-new-function-as-prop": "off",
+	"react-perf/jsx-no-new-object-as-prop": "off",
+	"react/display-name": "off",
+	"react/forbid-component-props": "off",
+	"react/jsx-filename-extension": "off",
+	"react/jsx-handler-names": "off",
+	"react/jsx-max-depth": "off",
+	"react/jsx-props-no-spreading": "off",
+	"react/no-multi-comp": "off",
+	"react/only-export-components": "off",
+	"react/react-in-jsx-scope": "off",
+	"react/rule-suppression": "off",
+	"typescript/consistent-return": "off",
+	"typescript/explicit-function-return-type": "off",
+	"typescript/explicit-module-boundary-types": "off",
+	"typescript/no-confusing-void-expression": "off",
+	"typescript/no-dynamic-delete": "off",
+	"typescript/no-invalid-void-type": "off",
+	"typescript/no-unnecessary-type-parameters": "off",
+	"typescript/no-unsafe-type-assertion": "off",
+	"typescript/prefer-nullish-coalescing": "off",
+	"typescript/prefer-readonly-parameter-types": "off",
+	"typescript/promise-function-async": "off",
+	"unicorn/no-array-callback-reference": "off",
+	"unicorn/no-array-reduce": "off",
+	"unicorn/no-nested-ternary": "off",
+	"unicorn/no-null": "off",
+	"unicorn/no-useless-undefined": "off",
+	"unicorn/number-literal-case": "off",
+	"unicorn/prefer-global-this": "off",
+	"unicorn/prefer-spread": "off",
+	"vitest/max-expects": "off",
+	"vitest/no-conditional-in-test": "off",
+	"vitest/no-hooks": "off",
+	"vitest/no-importing-vitest-globals": "off",
+	"vitest/no-standalone-expect": "off",
+	"vitest/prefer-called-once": "off",
+	"vitest/prefer-expect-assertions": "off",
+	"vitest/prefer-importing-vitest-globals": "off",
+	"vitest/prefer-lowercase-title": "off",
+	"vitest/prefer-to-be": "off",
+	"vitest/prefer-to-be-falsy": "off",
+	"vitest/prefer-to-be-truthy": "off",
+	"vitest/require-hook": "off",
+	"vitest/require-test-timeout": "off"
+};
+const disabledTailwindRules = {
+	"better-tailwindcss/enforce-consistent-class-order": "off",
+	"better-tailwindcss/enforce-consistent-line-wrapping": "off"
+};
+const overridenRules = {
+	"eslint/no-magic-numbers": ["error", { ignore: [
+		0,
+		1,
+		-1
+	] }],
+	"eslint/no-void": ["error", { allowAsStatement: true }],
+	"eslint/sort-imports": ["error", { ignoreDeclarationSort: true }],
+	"react/function-component-definition": ["error", {
+		namedComponents: "arrow-function",
+		unnamedComponents: "arrow-function"
+	}],
+	"react/jsx-no-useless-fragment": ["error", { allowExpressions: true }],
+	"typescript/consistent-type-definitions": ["error", "type"],
+	"typescript/no-misused-promises": ["error", { checksVoidReturn: {
+		arguments: false,
+		attributes: false
+	} }],
+	"typescript/no-unnecessary-condition": ["error", { allowConstantLoopConditions: true }],
+	"typescript/restrict-template-expressions": ["error", { allowNumber: true }],
+	"typescript/strict-boolean-expressions": ["error", {
+		allowNullableBoolean: true,
+		allowNullableNumber: true,
+		allowNullableString: true,
+		allowNumber: true,
+		allowString: true
+	}],
+	"typescript/switch-exhaustiveness-check": ["error", { considerDefaultExhaustiveForUnions: true }],
+	"unicorn/explicit-length-check": ["error", { "non-zero": "not-equal" }],
+	"unicorn/max-nested-calls": ["error", { max: 5 }],
+	"unicorn/switch-case-braces": ["error", "avoid"],
+	"vitest/consistent-test-it": ["error", { fn: "test" }]
+};
+const mergeConfigs$1 = (...configs) => configs.reduce(({ categories, env, globals, ignorePatterns, jsPlugins, options, overrides, plugins, rules, settings, ...rest }, { categories: configCategories, env: configEnv, globals: configGlobals, ignorePatterns: configIgnorePatterns, jsPlugins: configJsPlugins, options: configOptions, overrides: configOverrides, plugins: configPlugins, rules: configRules, settings: configSettings, ...configRest }) => ({
+	categories: {
+		...categories,
+		...configCategories
+	},
+	env: {
+		...env,
+		...configEnv
+	},
+	globals: {
+		...globals,
+		...configGlobals
+	},
+	ignorePatterns: [...ignorePatterns ?? [], ...configIgnorePatterns ?? []],
+	jsPlugins: [...jsPlugins ?? [], ...configJsPlugins ?? []],
+	options: {
+		...options,
+		...configOptions
+	},
+	overrides: [...overrides ?? [], ...configOverrides ?? []],
+	plugins: {
+		...plugins,
+		...configPlugins
+	},
+	rules: {
+		...rules,
+		...configRules
+	},
+	settings: {
+		...settings,
+		...configSettings
+	},
+	...rest,
+	...configRest
+}), {});
+const getTailwindConfig = async (config) => {
+	if (!config) return {};
+	const tailwindPlugin = await import("eslint-plugin-better-tailwindcss");
+	return {
+		jsPlugins: [{
+			name: "better-tailwindcss",
+			specifier: "eslint-plugin-better-tailwindcss"
+		}],
+		rules: {
+			...Object.fromEntries(Object.keys(tailwindPlugin.default.rules).map((key) => [`better-tailwindcss/${key}`, "error"])),
+			...disabledTailwindRules
+		},
+		settings: { "better-tailwindcss": { entryPoint: config.entryPoint } }
+	};
+};
+const getVitestConfig = (config) => {
+	if (!config) return {};
+	return {
+		overrides: config.files ? [{
+			files: config.files,
+			rules: { "react/rules-of-hooks": "off" }
+		}] : [],
+		plugins: { vitest: true }
+	};
+};
+const getTanstackRouterConfig = async (config) => {
+	if (!config) return {};
+	const plugin = await import("@tanstack/eslint-plugin-router");
+	return {
+		jsPlugins: [{
+			name: "@tanstack/router",
+			specifier: "@tanstack/eslint-plugin-router"
+		}],
+		overrides: [{
+			files: config.routes,
+			rules: { "no-use-before-define": "off" }
+		}],
+		rules: plugin.default.configs["flat/recommended"][0].rules
+	};
+};
+const getPackageJsonConfig = async (config) => {
+	if (!config) return {};
+	return {
+		jsPlugins: [{
+			name: "package-json",
+			specifier: "eslint-plugin-package-json"
+		}],
+		rules: (await import("eslint-plugin-package-json")).configs.recommended.rules
+	};
+};
+const getPlaywrightConfig = async (config) => {
+	if (!config) return {};
+	const plugin = await import("eslint-plugin-playwright");
+	return {
+		jsPlugins: [{
+			name: "playwright",
+			specifier: "eslint-plugin-playwright"
+		}],
+		overrides: [{
+			files: config.files,
+			rules: {
+				...plugin.default.configs["flat/recommended"].rules,
+				...config.assertFunctionNames ? { "playwright/expect-expect": ["error", { assertFunctionNames: config.assertFunctionNames }] } : {},
+				"react/rules-of-hooks": "off",
+				"vitest/consistent-test-filename": "off",
+				"vitest/prefer-each": "off",
+				"vitest/valid-expect": "off"
+			}
+		}]
+	};
+};
+const getServerSideConfig = (config) => {
+	if (!config) return {};
+	return { overrides: [
+		{
+			files: config.files,
+			rules: { "import/no-nodejs-modules": "off" }
+		},
+		config.allowConsole ? {
+			files: config.allowConsole,
+			rules: { "no-console": "off" }
+		} : null,
+		config.allowProcess ? {
+			files: config.allowProcess,
+			rules: { "node/no-process-env": "off" }
+		} : null
+	].filter(isNonNullish) };
+};
+const getRestrictedSyntaxConfig = (config) => {
+	if (!config) return {};
+	const overrides = config.overrides ?? [];
+	const rawRules = [config.banBarrelImport ? {
+		message: "Do not use barrel export, prefer named export",
+		selector: "ExportAllDeclaration"
+	} : null, config.banReactMemo ? {
+		message: "No need to use `React.memo`, we have a react compiler turned on",
+		selector: "MemberExpression[object.name='React'][property.name='memo']"
+	} : null].filter(isNonNullish);
+	return {
+		overrides: overrides.map(({ files, rules }) => ({
+			files,
+			rules: { "eslint-js/no-restricted-syntax": ["error", [
+				...rawRules,
+				...rules,
+				...config.rulesOverrides ?? []
+			]] }
+		})),
+		rules: { "eslint-js/no-restricted-syntax": [
+			"error",
+			...rawRules,
+			...config.rulesOverrides ?? []
+		] }
+	};
+};
+const getRestrictedConfig = (config) => {
+	if (!config) return {};
+	return { rules: {
+		"eslint/no-restricted-globals": config.globals ? ["error", ...config.globals] : "error",
+		"eslint/no-restricted-properties": config.properties ? ["error", ...config.properties] : "error"
+	} };
+};
+const getReactConfig = (config) => {
+	if (!config) return {};
+	return { rules: {
+		"react/exhaustive-deps": config.additionalHooks ? ["error", { additionalHooks: `(${config.additionalHooks.join(",")})` }] : "error",
+		"react/jsx-no-literals": ["error", {
+			allowedStrings: config.allowedStrings,
+			ignoreProps: true,
+			noAttributeStrings: true,
+			noStrings: true
+		}]
+	} };
+};
+const getI18nConfig = (config) => {
+	if (!config) return {};
+	return {
+		overrides: Array.isArray(config.ignore) ? [{
+			files: config.ignore,
+			rules: { "react/jsx-no-literals": "off" }
+		}] : [],
+		rules: config.ignore === true ? { "react/jsx-no-literals": "off" } : {}
+	};
+};
+const getImportConfig = (config) => {
+	if (!config) return {};
+	return { overrides: [config.allowDefault ? {
+		files: config.allowDefault,
+		rules: { "import/no-default-export": "off" }
+	} : null].filter(isNonNullish) };
+};
+const getBaseConfig$1 = () => ({
+	categories: {
+		correctness: "error",
+		nursery: "error",
+		pedantic: "error",
+		perf: "error",
+		restriction: "error",
+		style: "error",
+		suspicious: "error"
+	},
+	env: {
+		browser: true,
+		es2026: true
+	},
+	ignorePatterns: baseIgnorePatterns,
+	jsPlugins: [{
+		name: "eslint-js",
+		specifier: "oxlint-plugin-eslint"
+	}],
+	options: {
+		denyWarnings: true,
+		reportUnusedDisableDirectives: "error",
+		typeAware: true
+	},
+	overrides: [{
+		files: ["**/*.config.{j,t}s"],
+		rules: {
+			"import/no-default-export": "off",
+			"import/no-nodejs-modules": "off",
+			"node/no-top-level-await": "off"
+		}
+	}, {
+		files: ["**/*.d.ts"],
+		rules: { "typescript/triple-slash-reference": "off" }
+	}],
+	plugins: {
+		eslint: true,
+		import: true,
+		"jsx-a11y": true,
+		node: true,
+		oxc: true,
+		promise: true,
+		react: true,
+		"react-perf": true,
+		typescript: true,
+		unicorn: true
+	},
+	rules: {
+		...disabledRules,
+		...overridenRules
+	}
+});
+const getConfig$2 = async ({ tailwind, tanstackRouter, vitest, packageJson = true, playwright, serverSide, restricted, react, i18n, import: importOptions, ...config } = {}) => {
+	const baseConfig = getBaseConfig$1();
+	const tailwindConfig = await getTailwindConfig(tailwind);
+	const tanstackRouterConfig = await getTanstackRouterConfig(tanstackRouter);
+	const vitestConfig = getVitestConfig(vitest);
+	const packageJsonConfig = await getPackageJsonConfig(packageJson);
+	const playwrightConfig = await getPlaywrightConfig(playwright);
+	const serverSideConfig = getServerSideConfig(serverSide);
+	const reactConfig = getReactConfig(react);
+	const i18nConfig = getI18nConfig(i18n);
+	const importConfig = getImportConfig(importOptions);
+	const restrictedConfig = getRestrictedConfig(restricted);
+	const rawMergedConfig = mergeConfigs$1(baseConfig, vitestConfig, tanstackRouterConfig, packageJsonConfig, playwrightConfig, tailwindConfig, serverSideConfig, restrictedConfig, reactConfig, i18nConfig, importConfig, config);
+	const restrictedSyntaxConfig = getRestrictedSyntaxConfig({
+		banBarrelImport: importOptions?.banBarrel,
+		banReactMemo: react?.banMemo,
+		overrides: restricted?.syntaxOverrides,
+		previousOverrides: rawMergedConfig.overrides?.map((override) => override.rules?.["eslint-js/no-restricted-syntax"] === void 0 ? void 0 : {
+			files: override.files,
+			rules: override.rules["eslint-js/no-restricted-syntax"].slice(1)
+		}).filter(isNonNullish),
+		previousRules: (rawMergedConfig.rules?.["eslint-js/no-restricted-syntax"])?.slice(1),
+		rulesOverrides: restricted?.syntaxRulesOverrides
+	});
+	const { plugins: pluginsRecord = {}, ...mergedConfig } = mergeConfigs$1(rawMergedConfig, restrictedSyntaxConfig);
+	return {
+		...mergedConfig,
+		plugins: Object.entries(pluginsRecord).filter(([, value]) => value).map(([key]) => key)
+	};
+};
+//#endregion
+//#region src/oxfmt.ts
+const getConfig = async ({ ignorePatterns = [], tailwind, imports, sortImports, ...rest } = {}) => ({
+	astro: true,
+	ignorePatterns: [...baseIgnorePatterns, ...ignorePatterns],
+	printWidth: 80,
+	sortImports: sortImports ?? (imports ? {
+		newlinesBetween: false,
+		order: "asc",
+		...imports
+	} : true),
+	sortPackageJson: { sortScripts: true },
+	sortTailwindcss: tailwind ? {
+		functions: tailwind.functions,
+		stylesheet: tailwind.stylesheet
+	} : void 0,
+	useTabs: true,
+	...rest
+});
+//#endregion
+//#region src/knip.ts
+const mergeConfigs = (...configs) => configs.reduce(({ include, ignore, ignoreDependencies, entry, ignoreIssues, workspaces = {}, ...rest }, { include: configInclude, ignore: configIgnore, ignoreDependencies: configIgnoreDependencies, entry: configEntry, ignoreIssues: configIgnoreIssues, workspaces: configWorkspaces = {}, ...configRest }) => ({
+	entry: [...arraify(entry), ...arraify(configEntry)],
+	ignore: [...arraify(ignore), ...arraify(configIgnore)],
+	ignoreDependencies: [...arraify(ignoreDependencies), ...arraify(configIgnoreDependencies)],
+	ignoreIssues: {
+		...ignoreIssues,
+		...configIgnoreIssues
+	},
+	include: {
+		...include,
+		...configInclude
+	},
+	workspaces: {
+		...mapValues(workspaces, (workspace, key) => ({
+			...workspace,
+			...configWorkspaces[key]
+		})),
+		...omitBy(configWorkspaces, (_value, key) => Boolean(workspaces[key]))
+	},
+	...rest,
+	...configRest
+}), {});
+const getBaseConfig = ({ opencode = false, reactNative = false, eslint = true, vitest = true, workspaces = false } = {}) => ({
+	entry: workspaces ? [] : ["**/*.config.ts"],
+	ignore: [process.env.CI ? void 0 : ".history/**", opencode ? ".opencode/**" : void 0].filter(isNonNullish),
+	ignoreDependencies: [
+		reactNative ? "expo-doctor" : void 0,
+		vitest ? "@vitest/coverage-v8" : void 0,
+		eslint ? "oxlint-plugin-eslint" : void 0
+	].filter(isNonNullish),
+	ignoreIssues: { "**/*.gen.ts": ["types"] },
+	include: {
+		catalog: true,
+		catalogReferences: true,
+		cycles: true,
+		dependencies: true,
+		duplicates: true,
+		enumMembers: true,
+		exports: true,
+		files: true,
+		namespaceMembers: true,
+		nsExports: true,
+		nsTypes: true,
+		types: true,
+		unlisted: true,
+		unresolved: true
+	},
+	treatConfigHintsAsErrors: true,
+	treatTagHintsAsErrors: true,
+	workspaces: workspaces ? { ".": { entry: ["**/*.config.ts"] } } : {}
+});
+const getConfig$1 = async ({ options, ...overrides } = {}) => {
+	const baseConfig = getBaseConfig(options);
+	const { include: includeRecord = {}, ...mergedConfig } = mergeConfigs(baseConfig, overrides);
+	return {
+		...mergedConfig,
+		include: Object.entries(includeRecord).filter(([, value]) => value).map(([key]) => key)
+	};
+};
+//#endregion
+export { configSchema, disabledRules, getConfig as getFormatConfig, getConfig$1 as getKnipConfig, getConfig$2 as getLintConfig, overridenRules };

package/dist/schema-DM8wm8HH.mjs

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/config/schema.ts
+const configSchema = z.object({ preCommitCommands: z.string().array() }).partial();
+//#endregion
+export { configSchema as t };

package/package.json

@@ -1,6 +1,67 @@
 {
-  "name": "@oxiul/configs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@oxiul/configs",
+	"version": "0.3.2",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/oxiul/configs.git"
+	},
+	"files": [
+		"dist/**",
+		"scripts/postinstall.mjs"
+	],
+	"type": "module",
+	"sideEffects": false,
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"exports": {
+		"types": "./dist/index.d.mts",
+		"default": "./dist/index.mjs"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsdown",
+		"changeset": "changeset add",
+		"deps": "knip",
+		"format": "oxfmt --write",
+		"format:verify": "oxfmt --check",
+		"lint": "oxlint",
+		"lint:fix": "oxlint --fix",
+		"postinstall": "node scripts/postinstall.mjs",
+		"typecheck": "bun check"
+	},
+	"dependencies": {
+		"cosmiconfig": "^10.0.1",
+		"listr2": "^11.4.0",
+		"oxlint-plugin-eslint": "^1.88.0",
+		"zod": "^4.6.7"
+	},
+	"devDependencies": {
+		"@arethetypeswrong/core": "^0.18.5",
+		"@changesets/changelog-github": "^1.0.1",
+		"@changesets/cli": "^3.0.3",
+		"@tanstack/eslint-plugin-router": "^1.162.0",
+		"@types/bun": "1.4.3",
+		"eslint-plugin-better-tailwindcss": "^4.9.1",
+		"eslint-plugin-package-json": "^1.10.1",
+		"eslint-plugin-playwright": "^2.12.1",
+		"knip": "^6.42.0",
+		"oxfmt": "^0.73.0",
+		"oxlint": "^1.88.0",
+		"oxlint-tsgolint": "^7.0.2004",
+		"publint": "^0.3.25",
+		"remeda": "^2.52.0",
+		"tsdown": "^0.23.1"
+	},
+	"peerDependencies": {
+		"knip": "^6.42.0",
+		"oxfmt": "^0.73.0",
+		"oxlint": "^1.88.0"
+	},
+	"engines": {
+		"node": "26"
+	},
+	"packageManager": "bun@1.4.3"
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,39 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+if (process.env.CI) {
+	process.exit(0);
+}
+
+const readName = (dir) => {
+	try {
+		// oxlint-disable-next-line typescript/no-unsafe-argument
+		const fileContent = readFileSync(path.join(dir, "package.json"), "utf8");
+		// oxlint-disable-next-line typescript/no-unsafe-return typescript/no-unsafe-member-access
+		return JSON.parse(fileContent).name;
+	} catch {
+		return undefined;
+	}
+};
+
+// oxlint-disable-next-line typescript/no-unsafe-assignment
+const ownName = readName(process.cwd());
+
+let gitRoot = "";
+try {
+	gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "ignore"],
+	}).trim();
+} catch {
+	process.exit(0);
+}
+
+const [cmd, ...args] =
+	readName(gitRoot) === ownName
+		? ["bun", "src/hook/install.ts"]
+		: ["node", "dist/hook/install.mjs"];
+
+const result = spawnSync(cmd, args, { stdio: "inherit" });
+process.exit(result.status ?? 1);