@adamhl8/configs 0.16.3 → 0.17.0

package/dist/adamhl8-knip/index

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import process from "node:process";
+const KNIP_PREPROCESSOR_PATH = `${path.resolve(import.meta.dir, "../configs/knip-preprocessor")}`;
+const knipPreprocessorPathExt = await Bun.file(`${KNIP_PREPROCESSOR_PATH}.ts`).exists() ? ".ts" : ".js";
+const knipPreprocessorPath = `${KNIP_PREPROCESSOR_PATH}${knipPreprocessorPathExt}`;
+process.exitCode = Bun.spawnSync({
+	cmd: [
+		"knip-bun",
+		"--preprocessor",
+		knipPreprocessorPath,
+		...process.argv.slice(2)
+	],
+	stdout: "inherit",
+	stderr: "inherit"
+}).exitCode;
+export {};

package/dist/{knip-preprocessor.d.ts → configs/knip-preprocessor.d.ts}

@@ -1,6 +1,6 @@
 import { Preprocessor } from "knip";
 
-//#region src/knip-preprocessor.d.ts
+//#region src/configs/knip-preprocessor.d.ts
 declare const preprocess: Preprocessor;
 //#endregion
 export { preprocess as default };

package/dist/configs/knip-preprocessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knip-preprocessor.d.ts","names":[],"sources":["../../src/configs/knip-preprocessor.ts"],"sourcesContent":[],"mappings":";;;cA4BM,YAAY"}

package/dist/{knip-preprocessor.js → configs/knip-preprocessor.js}

@@ -1,5 +1,4 @@
 import { knipConfig } from "./knip.js";
-import "./index.js";
 const entries = knipConfig().entry;
 function filterIssues(options, issueType, filter) {
 	const issuesObject = options.issues[issueType];
@@ -16,7 +15,7 @@ const preprocess = (options) => {
 	filterIssues(options, "unlisted", ([key]) => !key.includes("prettier"));
 	filterIssues(options, "unlisted", ([, issueObj]) => Object.keys(issueObj).length > 0);
 	filterIssues(options, "types", ([key, issueObj]) => {
-		if (key !== "src/utils.ts") return true;
+		if (key !== "src/configs/utils.ts") return true;
 		const typeNames = Object.keys(issueObj);
 		const expectedTypeNames = ["MergeConfigFn", "OptionalMergeConfigFn"];
 		if (typeNames.length !== expectedTypeNames.length) return true;

package/dist/configs/knip-preprocessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"knip-preprocessor.js","names":["preprocess: Preprocessor"],"sources":["../../src/configs/knip-preprocessor.ts"],"sourcesContent":["import type { Preprocessor, ReporterOptions } from \"knip\"\nimport type { Issue, SymbolIssueType } from \"knip/dist/types/issues\"\n\nimport { knipConfig } from \"./knip.ts\"\n\nconst entries = knipConfig().entry as string[]\n\n/**\n * Filters issues based on the provided filter function.\n *\n * This is needed because we also need to update `options.counters` after filtering issues.\n */\nfunction filterIssues(\n  options: ReporterOptions,\n  issueType: SymbolIssueType,\n  filter: (issueEntry: [string, Record<string, Issue>]) => boolean,\n) {\n  const issuesObject = options.issues[issueType]\n  const filteredIssues = Object.fromEntries(Object.entries(issuesObject).filter(filter))\n\n  const issueCount = Object.keys(issuesObject).length\n  const filteredIssueCount = Object.keys(filteredIssues).length\n  const issuesRemovedCount = issueCount - filteredIssueCount\n\n  options.counters[issueType] = issueCount - issuesRemovedCount\n  options.issues[issueType] = filteredIssues\n}\n\nconst preprocess: Preprocessor = (options) => {\n  // ignore the \"Refine entry pattern (no matches)\" configuration hints for entries in the base config\n  const filteredConfigurationHints = [...options.configurationHints].filter(\n    (hint) =>\n      !(\n        entries.some((entry) => typeof hint.identifier === \"string\" && hint.identifier.includes(entry)) &&\n        (hint.type === \"entry-empty\" || hint.type === \"entry-redundant\")\n      ),\n  )\n  options.configurationHints = new Set(filteredConfigurationHints)\n\n  filterIssues(options, \"unlisted\", ([key]) => !key.includes(\"prettier\"))\n  filterIssues(options, \"unlisted\", ([, issueObj]) => Object.keys(issueObj).length > 0)\n\n  filterIssues(options, \"types\", ([key, issueObj]) => {\n    if (key !== \"src/configs/utils.ts\") return true\n    const typeNames = Object.keys(issueObj)\n    // We need to bring these types into scope of each merge config module: https://github.com/microsoft/TypeScript/issues/5711\n    const expectedTypeNames = [\"MergeConfigFn\", \"OptionalMergeConfigFn\"]\n    if (typeNames.length !== expectedTypeNames.length) return true // don't filter out the issue if there are other types\n    const foundAllExpectedTypeNames = expectedTypeNames.every((expectedTypeName) =>\n      typeNames.includes(expectedTypeName),\n    )\n    const shouldFilterIssue = !foundAllExpectedTypeNames // if all the expected type names are found, we need to return false to filter out the issue\n    return shouldFilterIssue\n  })\n\n  return options\n}\n\nexport default preprocess\n"],"mappings":";AAKA,MAAM,UAAU,YAAY,CAAC;AAO7B,SAAS,aACP,SACA,WACA,QACA;CACA,MAAM,eAAe,QAAQ,OAAO;CACpC,MAAM,iBAAiB,OAAO,YAAY,OAAO,QAAQ,aAAa,CAAC,OAAO,OAAO,CAAC;CAEtF,MAAM,aAAa,OAAO,KAAK,aAAa,CAAC;CAC7C,MAAM,qBAAqB,OAAO,KAAK,eAAe,CAAC;CACvD,MAAM,qBAAqB,aAAa;AAExC,SAAQ,SAAS,aAAa,aAAa;AAC3C,SAAQ,OAAO,aAAa;;AAG9B,MAAMA,cAA4B,YAAY;CAE5C,MAAM,6BAA6B,CAAC,GAAG,QAAQ,mBAAmB,CAAC,QAChE,SACC,EACE,QAAQ,MAAM,UAAU,OAAO,KAAK,eAAe,YAAY,KAAK,WAAW,SAAS,MAAM,CAAC,KAC9F,KAAK,SAAS,iBAAiB,KAAK,SAAS,oBAEnD;AACD,SAAQ,qBAAqB,IAAI,IAAI,2BAA2B;AAEhE,cAAa,SAAS,aAAa,CAAC,SAAS,CAAC,IAAI,SAAS,WAAW,CAAC;AACvE,cAAa,SAAS,aAAa,GAAG,cAAc,OAAO,KAAK,SAAS,CAAC,SAAS,EAAE;AAErF,cAAa,SAAS,UAAU,CAAC,KAAK,cAAc;AAClD,MAAI,QAAQ,uBAAwB,QAAO;EAC3C,MAAM,YAAY,OAAO,KAAK,SAAS;EAEvC,MAAM,oBAAoB,CAAC,iBAAiB,wBAAwB;AACpE,MAAI,UAAU,WAAW,kBAAkB,OAAQ,QAAO;AAK1D,SAD0B,CAHQ,kBAAkB,OAAO,qBACzD,UAAU,SAAS,iBAAiB,CACrC;GAGD;AAEF,QAAO;;AAGT,IAAA,4BAAe"}

package/dist/{knip.d.ts → configs/knip.d.ts}

@@ -1,6 +1,6 @@
 import { OptionalMergeConfigFn } from "./utils.js";
 
-//#region src/knip.d.ts
+//#region src/configs/knip.d.ts
 declare const knipConfig: OptionalMergeConfigFn<{
   node?: string | boolean | string[] | {
     config?: string | string[] | undefined;

package/dist/{knip.d.ts.map → configs/knip.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"knip.d.ts","names":[],"sources":["../src/knip.ts"],"sourcesContent":[],"mappings":";;;cAca;;;IAAA,KAAA,CAAA,EAAA,MAA2E,GAAA,MAAA,EAAA,GAAA,SAAA;IAAA,OAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;;;;;;;;;;IAC6muP,MAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;;;MAAoP,SAAA;;IAA0rzB,MAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;IAA+G,KAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;IAA8D,OAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;MAAyD,SAAA;OAA4D,CAAA,EAAA,MAAA,GAAA,OAAA,GAAA,MAAA,EAAA,GAAA;;;IAD93iR,OAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gKAC8quP;;0FAAoP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAA0rzB;;+BAA+G;mCAA8D;8BAAyD;iCAA4D"}
+{"version":3,"file":"knip.d.ts","names":[],"sources":["../../src/configs/knip.ts"],"sourcesContent":[],"mappings":";;;cAca;;;IAAA,KAAA,CAAA,EAAA,MAA2E,GAAA,MAAA,EAAA,GAAA,SAAA;IAAA,OAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;;;;;;;;;;IAC6muP,MAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;;;MAAoP,SAAA;;IAA0rzB,MAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;IAA+G,KAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;IAA8D,OAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;MAAyD,SAAA;OAA4D,CAAA,EAAA,MAAA,GAAA,OAAA,GAAA,MAAA,EAAA,GAAA;;;IAD93iR,OAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gKAC8quP;;0FAAoP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAA0rzB;;+BAA+G;mCAA8D;8BAAyD;iCAA4D"}

package/dist/configs/knip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"knip.js","names":[],"sources":["../../src/configs/knip.ts"],"sourcesContent":["import type { KnipConfig } from \"knip\"\n\nimport { createMergeConfigFn } from \"./utils.ts\"\n\n// Normally, specifying the `./src/index.ts` entry would cause knip to complain about a redundant entry because it gets automatically included via the tsdown plugin.\n// However, in projects that _don't_ use tsdown, the `./src/index.ts` entry would be missing entirely.\n// To handle this, we specify it and disable the tsdown plugin. This makes knip work in both cases.\n\nconst baseConfig = {\n  entry: [\"./src/index.ts\", \"**/*.test.ts\", \"./tsdown.config.ts\"],\n  project: [\"**\"],\n  tsdown: false,\n} as const satisfies KnipConfig\n\nexport const knipConfig = createMergeConfigFn<KnipConfig, typeof baseConfig>(baseConfig)\n"],"mappings":";AAcA,MAAa,aAAa,oBANP;CACjB,OAAO;EAAC;EAAkB;EAAgB;EAAqB;CAC/D,SAAS,CAAC,KAAK;CACf,QAAQ;CACT,CAEuF"}

package/dist/{prettier.d.ts → configs/prettier.d.ts}

@@ -1,7 +1,7 @@
 import { OptionalMergeConfigFn } from "./utils.js";
 import * as prettier0 from "prettier";
 
-//#region src/prettier.d.ts
+//#region src/configs/prettier.d.ts
 declare const prettierConfig: OptionalMergeConfigFn<{
   [x: string]: unknown;
   overrides?: Array<{

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

@@ -0,0 +1 @@
+{"version":3,"file":"prettier.d.ts","names":[],"sources":["../../src/configs/prettier.ts"],"sourcesContent":[],"mappings":";;;;cAoCa;;;;IAAA,YAAA,CAAmF,EAAA,MAAA,GAAA,MAAA,EAAA;IAAA,OAAA,CAAA,EAAA,SAAA,CACwpP,OADxpP;;;;;;;;;EAArE,UAAA,CAAA,EAAA,MAAA"}

package/dist/configs/prettier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettier.js","names":[],"sources":["../../src/configs/prettier.ts"],"sourcesContent":["import type { Config } from \"prettier\"\nimport type { Simplify } from \"type-fest\"\n\nimport { createMergeConfigFn } from \"./utils.ts\"\n\n// for some reason the Config type from prettier doesn't satisfy AnyObj unless we simplify it\ntype PrettierConfig = Simplify<Config>\n\nconst baseConfig = {\n  printWidth: 120,\n  semi: false,\n  plugins: [\n    \"@prettier/plugin-xml\",\n    \"prettier-plugin-sh\",\n    \"prettier-plugin-toml\",\n    \"prettier-plugin-astro\",\n    \"prettier-plugin-tailwindcss\",\n  ],\n  tailwindStylesheet: \"./src/global.css\",\n  overrides: [\n    {\n      // https://github.com/prettier/prettier/issues/15956\n      files: \"*.jsonc\",\n      options: {\n        trailingComma: \"none\",\n      },\n    },\n    {\n      files: \"*.astro\",\n      options: {\n        parser: \"astro\",\n      },\n    },\n  ],\n} as const satisfies PrettierConfig\n\nexport const prettierConfig = createMergeConfigFn<PrettierConfig, typeof baseConfig>(baseConfig)\n"],"mappings":";AAoCA,MAAa,iBAAiB,oBA5BX;CACjB,YAAY;CACZ,MAAM;CACN,SAAS;EACP;EACA;EACA;EACA;EACA;EACD;CACD,oBAAoB;CACpB,WAAW,CACT;EAEE,OAAO;EACP,SAAS,EACP,eAAe,QAChB;EACF,EACD;EACE,OAAO;EACP,SAAS,EACP,QAAQ,SACT;EACF,CACF;CACF,CAE+F"}

package/dist/{tsdown.d.ts → configs/tsdown.d.ts}

@@ -5,7 +5,7 @@ import * as rolldown_plugin_dts0 from "rolldown-plugin-dts";
 import * as publint0 from "publint";
 import * as hookable0 from "hookable";
 
-//#region src/tsdown.d.ts
+//#region src/configs/tsdown.d.ts
 declare const tsdownConfig: MergeConfigFn<{
   entry?: rolldown0.InputOption;
   external?: rolldown0.ExternalOption;

package/dist/configs/tsdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsdown.d.ts","names":[],"sources":["../../src/configs/tsdown.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAyCa;UAAyF,SAAA,CAAA;;;;;;;EAAzF,GAAA,CAAA,QAAA,CAAA,MAAyF,EAAA,GAAA,CAAA;EAAA,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,MAAA,CAAA;OAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA7E,SAAA,MAAA,EAAA,KAAA;EACZ,SAAA,QAAA,EAAwF,SAAA;EAAA,SAAA,MAAA,EAAA,UAAA;WAAA,SAAzE,EAAA,IAAA;WAAA,IAAA,EAAA,KAAA;WAAA,GAAA,EAAA;IAAA,SAAA,UAAA,EAAA,IAAA;;;;;;;;;;cAAf,iBAAe,sBAAA,KAAyE,OAAA,CAAzE,OAAA"}

package/dist/configs/tsdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsdown.js","names":[],"sources":["../../src/configs/tsdown.ts"],"sourcesContent":["import type { NormalizedUserConfig } from \"tsdown\"\nimport type { SetRequired } from \"type-fest\"\n\nimport { createMergeConfigFn } from \"./utils.ts\"\n\n// force projects to specify platform\ntype StrictUserConfig = SetRequired<NormalizedUserConfig, \"platform\">\n\nconst baseConfig = {\n  entry: [\"./src/index.ts\"],\n  unbundle: true,\n  target: false,\n  platform: \"neutral\",\n  minify: \"dce-only\",\n  sourcemap: true,\n  hash: false,\n  dts: {\n    newContext: true,\n    sourcemap: true,\n  },\n  attw: {\n    level: \"error\",\n    profile: \"esmOnly\",\n  },\n  publint: true,\n  failOnWarn: true,\n} as const satisfies StrictUserConfig\n\nconst binConfig = {\n  ...baseConfig,\n  entry: [],\n  platform: \"node\",\n  outExtensions: () => ({ js: \"\" }),\n  copy: [],\n  unbundle: false,\n  sourcemap: false,\n  dts: false,\n  attw: false,\n  publint: false,\n} as const satisfies NormalizedUserConfig\n\nexport const tsdownConfig = createMergeConfigFn<StrictUserConfig, typeof baseConfig, true>(baseConfig)\nexport const tsdownBinConfig = createMergeConfigFn<NormalizedUserConfig, typeof binConfig>(binConfig)\n"],"mappings":";AAQA,MAAM,aAAa;CACjB,OAAO,CAAC,iBAAiB;CACzB,UAAU;CACV,QAAQ;CACR,UAAU;CACV,QAAQ;CACR,WAAW;CACX,MAAM;CACN,KAAK;EACH,YAAY;EACZ,WAAW;EACZ;CACD,MAAM;EACJ,OAAO;EACP,SAAS;EACV;CACD,SAAS;CACT,YAAY;CACb;AAED,MAAM,YAAY;CAChB,GAAG;CACH,OAAO,EAAE;CACT,UAAU;CACV,sBAAsB,EAAE,IAAI,IAAI;CAChC,MAAM,EAAE;CACR,UAAU;CACV,WAAW;CACX,KAAK;CACL,MAAM;CACN,SAAS;CACV;AAED,MAAa,eAAe,oBAA+D,WAAW;AACtG,MAAa,kBAAkB,oBAA4D,UAAU"}

package/dist/{utils.d.ts → configs/utils.d.ts}

@@ -1,6 +1,6 @@
 import { MergeDeep } from "type-fest";
 
-//#region src/utils.d.ts
+//#region src/configs/utils.d.ts
 
 /**
  * Type representing a merge config function, where the `UserConfig` passed in is merged with `BaseConfig`.

package/dist/configs/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/configs/utils.ts"],"sourcesContent":[],"mappings":";;;;;AAkBA;;AAE6B,UAFZ,aAEY,CAAA,UAAA,EAAA,UAAA,CAAA,CAAA;6BAAA,UACb,CAAA,CAAA,UAAA,EAAA,iBAAA,CAAA,EACX,SADW,CACD,UADC,EACW,iBADX,EAAA;IACD,cAAA,EAAA,QAAA;;;;AAaf;;;;;;;;UAAiB,sDAAsD,cAAc,YAAY;MAC3F"}

package/dist/configs/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/configs/utils.ts"],"sourcesContent":["import { mergeWith } from \"es-toolkit\"\nimport { clone } from \"remeda\"\nimport type { MergeDeep } from \"type-fest\"\n\ntype AnyObj = Record<PropertyKey, unknown>\n\n/**\n * A wrapper around es-toolkit's `mergeWith` with a custom merge function that concatenates arrays.\n */\nfunction merge<T extends AnyObj, S extends AnyObj>(target: T, source: S): T & S {\n  return mergeWith(target, source, (objValue: unknown, srcValue: unknown) =>\n    Array.isArray(objValue) ? objValue.concat(srcValue) : undefined,\n  )\n}\n\n/**\n * Type representing a merge config function, where the `UserConfig` passed in is merged with `BaseConfig`.\n */\nexport interface MergeConfigFn<UserConfig, BaseConfig> {\n  // biome-ignore lint/style/useShorthandFunctionType: need to use call signature type\n  <UserConfigToMerge extends UserConfig>(\n    userConfig: UserConfigToMerge,\n  ): MergeDeep<BaseConfig, UserConfigToMerge, { arrayMergeMode: \"spread\" }>\n  // instead of returning `BaseConfig & UserConfig` (from `merge`), return a more friendly type using `MergeDeep`\n}\n\n/**\n * Type representing an overloaded function signature for MergeConfigFn:\n * - if `UserConfig` is not provided, the return type is `BaseConfig`\n * - if `UserConfig` is provided, the return type is the merged type of `BaseConfig` and `UserConfig`.\n *\n * This is needed to handle the fact that the `userConfig` argument is optional.\n *\n * Note that this extends `MergeConfigFn`, so this type has both function signatures on it.\n */\nexport interface OptionalMergeConfigFn<UserConfig, BaseConfig> extends MergeConfigFn<UserConfig, BaseConfig> {\n  (): BaseConfig\n}\n\n/**\n * Creates a config merge function with proper type overloads for merging with a base config.\n */\nexport function createMergeConfigFn<\n  UserConfig extends AnyObj,\n  BaseConfig extends UserConfig,\n  Required extends boolean = false, // if true, the created merge config function requires a userConfig to be passed in\n>(baseConfig: BaseConfig) {\n  // we don't care about the specific type of userConfig here because we assert mergeConfigFn as the correct type below\n  const mergeConfigFn = (userConfig?: AnyObj) => {\n    if (userConfig === undefined) return baseConfig\n    // clone both target and source so we never mutate the original objects\n    return merge(clone(baseConfig), clone(userConfig))\n  }\n\n  return mergeConfigFn as Required extends true // if Required is true\n    ? MergeConfigFn<UserConfig, BaseConfig> // then the merge config function requires a userConfig to be passed in\n    : OptionalMergeConfigFn<UserConfig, BaseConfig> // else, userConfig is optional\n}\n"],"mappings":";;AASA,SAAS,MAA0C,QAAW,QAAkB;AAC9E,QAAO,UAAU,QAAQ,SAAS,UAAmB,aACnD,MAAM,QAAQ,SAAS,GAAG,SAAS,OAAO,SAAS,GAAG,KAAA,EACvD;;AA8BH,SAAgB,oBAId,YAAwB;CAExB,MAAM,iBAAiB,eAAwB;AAC7C,MAAI,eAAe,KAAA,EAAW,QAAO;AAErC,SAAO,MAAM,MAAM,WAAW,EAAE,MAAM,WAAW,CAAC;;AAGpD,QAAO"}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { knipConfig } from "./knip.js";
-import { prettierConfig } from "./prettier.js";
-import { tsdownBinConfig, tsdownConfig } from "./tsdown.js";
+import { knipConfig } from "./configs/knip.js";
+import { prettierConfig } from "./configs/prettier.js";
+import { tsdownBinConfig, tsdownConfig } from "./configs/tsdown.js";
 export { knipConfig, prettierConfig, tsdownBinConfig, tsdownConfig };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { knipConfig } from "./knip.js";
-import { prettierConfig } from "./prettier.js";
-import { tsdownBinConfig, tsdownConfig } from "./tsdown.js";
+import { knipConfig } from "./configs/knip.js";
+import { prettierConfig } from "./configs/prettier.js";
+import { tsdownBinConfig, tsdownConfig } from "./configs/tsdown.js";
 export { knipConfig, prettierConfig, tsdownBinConfig, tsdownConfig };

package/dist/ts-import-fix/index

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import path from "node:path";
+import process from "node:process";
+import fs from "node:fs/promises";
+import pc from "picocolors";
+import { attempt, err, isErr } from "ts-explicit-errors";
+import { message, multiple, object, option, string } from "@optique/core";
+import { run } from "@optique/run";
+import ts from "typescript";
+import fss from "node:fs";
+import { getTsconfig } from "get-tsconfig";
+function cli() {
+	const options = object({
+		write: option("-w", "--write", { description: message`Write changes to files` }),
+		skipAlias: option("--skip-alias", { description: message`Skip transforming relative imports to use an alias` }),
+		fileIgnorePatterns: multiple(option("-f", "--file-ignore", string({ metavar: "PATTERN" }), { description: message`Additional glob patterns for files to ignore (only applies to import fixes)` })),
+		importIgnoreStrings: multiple(option("-i", "--import-ignore", string(), { description: message`An import path *containing* the given string will be ignored` }))
+	});
+	return run(options, {
+		programName: "ts-import-fix",
+		help: "option",
+		showDefault: { prefix: " [default: " }
+	});
+}
+async function checkExports(filePaths) {
+	const EXPORT_ERRORS = [];
+	const exportCheckResult = await attempt(() => {
+		const filePromises = filePaths.map(async (filePath) => {
+			const filePathParts = path.parse(filePath);
+			if (filePathParts.name === "index") return;
+			const sourceCode = await fs.readFile(filePath, "utf8");
+			const sourceFile = ts.createSourceFile(filePathParts.base, sourceCode, ts.ScriptTarget.Latest, true);
+			const exportDeclarations = [];
+			const visit = (node) => {
+				if (ts.isExportDeclaration(node)) exportDeclarations.push(node);
+				ts.forEachChild(node, visit);
+			};
+			visit(sourceFile);
+			if (exportDeclarations.length === 0) return;
+			const exportDeclarationText = exportDeclarations.map((declaration) => declaration.getText()).join("\n");
+			EXPORT_ERRORS.push(`${pc.redBright("✗")} ${filePath}\n${pc.dim(exportDeclarationText)}\n`);
+		});
+		return Promise.all(filePromises);
+	});
+	if (isErr(exportCheckResult)) return err("something went wrong when checking exports", exportCheckResult);
+	if (EXPORT_ERRORS.length > 0) return err(`found export declarations:\n${EXPORT_ERRORS.join("\n")}`, void 0);
+}
+const IMPORT_PATTERN = /(?:import|from)\s+['"]([^'"]+)['"]$/gm;
+function getPathsMap() {
+	const tsconfig = getTsconfig();
+	if (!tsconfig) return err("failed to load tsconfig", void 0);
+	const pathsMap = {};
+	for (let [alias, [aliasDir]] of Object.entries(tsconfig.config.compilerOptions?.paths ?? {})) {
+		if (!alias.endsWith("/*")) continue;
+		if (!aliasDir?.endsWith("/*")) continue;
+		aliasDir = aliasDir.slice(0, -2);
+		alias = alias.slice(0, -2);
+		pathsMap[alias] = aliasDir;
+	}
+	return pathsMap;
+}
+function changeExtension(parsedPath, newExtension) {
+	return {
+		...parsedPath,
+		ext: newExtension,
+		base: ""
+	};
+}
+function transformExtension(filePath) {
+	const pathParts = path.parse(filePath);
+	if (!(pathParts.ext === ".js" || pathParts.ext === "")) return filePath;
+	return path.format(changeExtension(pathParts, ".ts"));
+}
+function transformRelativeImport(filePath, importPath, pathsMap) {
+	const currentDir = path.dirname(filePath);
+	const absoluteImportPath = path.resolve(currentDir, importPath);
+	if (!fss.existsSync(absoluteImportPath)) return err(`skipped transform of '${importPath}': target file does not exist`, void 0);
+	for (const [alias, aliasDir] of Object.entries(pathsMap)) {
+		const relativeToAliasDir = path.relative(aliasDir, absoluteImportPath);
+		if (relativeToAliasDir.startsWith("..")) continue;
+		return `${alias}/${relativeToAliasDir}`;
+	}
+	return err(`could not find alias for '${importPath}'`, void 0);
+}
+async function fixImports(filePaths, { write, importIgnoreStrings, skipAlias }) {
+	const IMPORT_ERRORS = [];
+	const TRANSFORMED_IMPORTS = [];
+	const pathsMap = getPathsMap();
+	if (isErr(pathsMap)) return pathsMap;
+	const importFixResult = await attempt(() => {
+		const filePromises = filePaths.map(async (filePath) => {
+			const content = await fs.readFile(filePath, "utf8");
+			const importErrorsForFile = [];
+			const transformedImportsForFile = [];
+			const transformedContent = content.replace(IMPORT_PATTERN, (match, importPath) => {
+				const isRelativeImport = importPath.startsWith("./") || importPath.startsWith("../");
+				const isAliasImport = Object.keys(pathsMap).some((alias) => importPath.startsWith(alias));
+				if (!(isRelativeImport || isAliasImport)) return match;
+				if (importIgnoreStrings.some((ignoreString) => importPath.includes(ignoreString))) return match;
+				let newImportPath = transformExtension(importPath);
+				if (isRelativeImport && !skipAlias) {
+					const transformedRelativeImport = transformRelativeImport(filePath, newImportPath, pathsMap);
+					if (isErr(transformedRelativeImport)) importErrorsForFile.push(transformedRelativeImport.messageChain);
+					else newImportPath = transformedRelativeImport;
+				}
+				if (newImportPath === importPath) return match;
+				const { ext: originalExt } = path.parse(importPath);
+				const newPathParts = path.parse(newImportPath);
+				const { ext: newExt } = newPathParts;
+				let newImportPathString = newImportPath;
+				if (newExt !== originalExt) newImportPathString = `${path.format(changeExtension(newPathParts, ""))}${pc.greenBright(newExt)}`;
+				transformedImportsForFile.push(`'${importPath}' -> '${newImportPathString}'`);
+				return match.replace(importPath, newImportPath);
+			});
+			if (importErrorsForFile.length > 0) IMPORT_ERRORS.push(`${pc.redBright("✗")} ${filePath}\n${importErrorsForFile.join("\n")}\n`);
+			if (transformedImportsForFile.length > 0) TRANSFORMED_IMPORTS.push(`${pc.greenBright("✓")} ${filePath}\n${transformedImportsForFile.join("\n")}\n`);
+			if (transformedContent === content) return;
+			if (write) await fs.writeFile(filePath, transformedContent);
+		});
+		return Promise.all(filePromises);
+	});
+	if (TRANSFORMED_IMPORTS.length > 0) console.log(`${pc.greenBright("[ts-import-fix]")} transformed imports:\n${TRANSFORMED_IMPORTS.join("\n")}`);
+	if (isErr(importFixResult)) return err("something went wrong when transforming imports", importFixResult);
+	if (IMPORT_ERRORS.length > 0) return err(`failed to transform some imports:\n${IMPORT_ERRORS.join("\n")}`, void 0);
+}
+const FILES_GLOB = "**/*.{ts,tsx,js,jsx,astro}";
+const BASE_IGNORE_PATTERNS = ["node_modules/", "dist/"];
+async function tsImportFix() {
+	const { fileIgnorePatterns,...fixImportsOptions } = cli();
+	const errors = [];
+	const fixImportsIgnorePatterns = [
+		...BASE_IGNORE_PATTERNS,
+		"astro.config.ts",
+		...fileIgnorePatterns
+	];
+	const [fixImportsFilePaths, checkExportsFilePaths] = await Promise.all([Array.fromAsync(fs.glob(FILES_GLOB, { exclude: fixImportsIgnorePatterns })), Array.fromAsync(fs.glob(FILES_GLOB, { exclude: BASE_IGNORE_PATTERNS }))]);
+	const fixImportsResult = await fixImports(fixImportsFilePaths, fixImportsOptions);
+	if (isErr(fixImportsResult)) errors.push(fixImportsResult);
+	const checkExportsResult = await checkExports(checkExportsFilePaths);
+	if (isErr(checkExportsResult)) errors.push(checkExportsResult);
+	return errors;
+}
+async function main() {
+	const errors = await tsImportFix();
+	if (errors.length === 0) {
+		console.log(`${pc.greenBright("[ts-import-fix]")} Done`);
+		return 0;
+	}
+	const errorMessage = errors.map((error) => `${pc.redBright("[ts-import-fix]")} ${error.messageChain}`).join("\n\n");
+	process.stderr.write(`${errorMessage}\n`);
+	return 1;
+}
+if (import.meta.main) process.exitCode = await main();
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adamhl8/configs",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,12 +17,12 @@
   },
   "license": "MIT",
   "bin": {
-    "adamhl8-knip": "./dist/adamhl8-knip",
-    "ts-import-fix": "./dist/ts-import-fix"
+    "adamhl8-knip": "./dist/adamhl8-knip/index",
+    "ts-import-fix": "./dist/ts-import-fix/index"
   },
   "exports": {
-    "./tsconfig": "./dist/tsconfig.base.json",
-    "./biome": "./dist/biome.base.json",
+    "./tsconfig": "./dist/configs/tsconfig.base.json",
+    "./biome": "./dist/configs/biome.base.json",
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
@@ -31,34 +31,37 @@
   "files": ["./dist/"],
   "scripts": {
     "bundle": "bun lint && tsdown",
-    "lint": "bun ./generate-biome-rules.ts && markdown-toc -i --bullets '-' --maxdepth 3 ./README.md && tsc --noEmit && biome check --write && ./src/adamhl8-knip.ts",
+    "lint": "bun ./generate-biome-rules.ts && markdown-toc -i --bullets '-' --maxdepth 3 ./README.md && ./src/ts-import-fix/index.ts -w --skip-alias && tsc --noEmit && biome check --write && ./src/adamhl8-knip/index.ts",
     "prepare": "find .githooks -type f -exec ln -srf {} .git/hooks/ \\; || true",
     "prepublishOnly": "bun bundle"
   },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
   "dependencies": {
+    "@optique/core": "^0.5.0-dev.83",
+    "@optique/run": "^0.5.0-dev.83",
     "@prettier/plugin-xml": "^3.4.2",
     "es-toolkit": "^1.39.10",
+    "get-tsconfig": "^4.10.1",
+    "picocolors": "^1.1.1",
     "prettier-plugin-astro": "^0.14.1",
     "prettier-plugin-sh": "^0.18.0",
     "prettier-plugin-tailwindcss": "^0.6.14",
     "prettier-plugin-toml": "^2.0.6",
     "remeda": "^2.32.0",
+    "ts-explicit-errors": "^4.0.1",
+    "tsdown": "^0.15.4",
     "type-fest": "^5.0.1"
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.2",
     "@biomejs/biome": "^2.2.4",
-    "@optique/core": "^0.5.0-dev.83",
-    "@optique/run": "^0.5.0-dev.83",
     "@types/bun": "^1.2.22",
-    "get-tsconfig": "^4.10.1",
     "knip": "^5.63.1",
     "markdown-toc": "^1.2.0",
-    "picocolors": "^1.1.1",
     "prettier": "^3.6.2",
     "publint": "^0.3.13",
-    "ts-explicit-errors": "^4.0.1",
-    "tsdown": "^0.15.4",
     "typescript": "^5.9.2"
   },
   "publishConfig": {

package/dist/adamhl8-knip

@@ -1,17 +0,0 @@
-#!/usr/bin/env bun
-import path from "node:path";
-import process from "node:process";
-const baseKnipPreprocessorPath = `${path.resolve(import.meta.dir, "./knip-preprocessor")}`;
-const knipPreprocessorPathExt = await Bun.file(`${baseKnipPreprocessorPath}.ts`).exists() ? ".ts" : ".js";
-const knipPreprocessorPath = `${baseKnipPreprocessorPath}${knipPreprocessorPathExt}`;
-process.exitCode = Bun.spawnSync({
-	cmd: [
-		"knip-bun",
-		"--preprocessor",
-		knipPreprocessorPath,
-		...process.argv.slice(2)
-	],
-	stdout: "inherit",
-	stderr: "inherit"
-}).exitCode;
-export {};

package/dist/knip-preprocessor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"knip-preprocessor.d.ts","names":[],"sources":["../src/knip-preprocessor.ts"],"sourcesContent":[],"mappings":";;;cA4BM,YAAY"}

package/dist/knip-preprocessor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"knip-preprocessor.js","names":["preprocess: Preprocessor"],"sources":["../src/knip-preprocessor.ts"],"sourcesContent":["import type { Preprocessor, ReporterOptions } from \"knip\"\nimport type { Issue, SymbolIssueType } from \"knip/dist/types/issues\"\n\nimport { knipConfig } from \"./index.ts\"\n\nconst entries = knipConfig().entry as string[]\n\n/**\n * Filters issues based on the provided filter function.\n *\n * This is needed because we also need to update `options.counters` after filtering issues.\n */\nfunction filterIssues(\n  options: ReporterOptions,\n  issueType: SymbolIssueType,\n  filter: (issueEntry: [string, Record<string, Issue>]) => boolean,\n) {\n  const issuesObject = options.issues[issueType]\n  const filteredIssues = Object.fromEntries(Object.entries(issuesObject).filter(filter))\n\n  const issueCount = Object.keys(issuesObject).length\n  const filteredIssueCount = Object.keys(filteredIssues).length\n  const issuesRemovedCount = issueCount - filteredIssueCount\n\n  options.counters[issueType] = issueCount - issuesRemovedCount\n  options.issues[issueType] = filteredIssues\n}\n\nconst preprocess: Preprocessor = (options) => {\n  // ignore the \"Refine entry pattern (no matches)\" configuration hints for entries in the base config\n  const filteredConfigurationHints = [...options.configurationHints].filter(\n    (hint) =>\n      !(\n        entries.some((entry) => typeof hint.identifier === \"string\" && hint.identifier.includes(entry)) &&\n        (hint.type === \"entry-empty\" || hint.type === \"entry-redundant\")\n      ),\n  )\n  options.configurationHints = new Set(filteredConfigurationHints)\n\n  filterIssues(options, \"unlisted\", ([key]) => !key.includes(\"prettier\"))\n  filterIssues(options, \"unlisted\", ([, issueObj]) => Object.keys(issueObj).length > 0)\n\n  filterIssues(options, \"types\", ([key, issueObj]) => {\n    if (key !== \"src/utils.ts\") return true\n    const typeNames = Object.keys(issueObj)\n    // We need to bring these types into scope of each merge config module: https://github.com/microsoft/TypeScript/issues/5711\n    const expectedTypeNames = [\"MergeConfigFn\", \"OptionalMergeConfigFn\"]\n    if (typeNames.length !== expectedTypeNames.length) return true // don't filter out the issue if there are other types\n    const foundAllExpectedTypeNames = expectedTypeNames.every((expectedTypeName) =>\n      typeNames.includes(expectedTypeName),\n    )\n    const shouldFilterIssue = !foundAllExpectedTypeNames // if all the expected type names are found, we need to return false to filter out the issue\n    return shouldFilterIssue\n  })\n\n  return options\n}\n\nexport default preprocess\n"],"mappings":";;AAKA,MAAM,UAAU,YAAY,CAAC;AAO7B,SAAS,aACP,SACA,WACA,QACA;CACA,MAAM,eAAe,QAAQ,OAAO;CACpC,MAAM,iBAAiB,OAAO,YAAY,OAAO,QAAQ,aAAa,CAAC,OAAO,OAAO,CAAC;CAEtF,MAAM,aAAa,OAAO,KAAK,aAAa,CAAC;CAC7C,MAAM,qBAAqB,OAAO,KAAK,eAAe,CAAC;CACvD,MAAM,qBAAqB,aAAa;AAExC,SAAQ,SAAS,aAAa,aAAa;AAC3C,SAAQ,OAAO,aAAa;;AAG9B,MAAMA,cAA4B,YAAY;CAE5C,MAAM,6BAA6B,CAAC,GAAG,QAAQ,mBAAmB,CAAC,QAChE,SACC,EACE,QAAQ,MAAM,UAAU,OAAO,KAAK,eAAe,YAAY,KAAK,WAAW,SAAS,MAAM,CAAC,KAC9F,KAAK,SAAS,iBAAiB,KAAK,SAAS,oBAEnD;AACD,SAAQ,qBAAqB,IAAI,IAAI,2BAA2B;AAEhE,cAAa,SAAS,aAAa,CAAC,SAAS,CAAC,IAAI,SAAS,WAAW,CAAC;AACvE,cAAa,SAAS,aAAa,GAAG,cAAc,OAAO,KAAK,SAAS,CAAC,SAAS,EAAE;AAErF,cAAa,SAAS,UAAU,CAAC,KAAK,cAAc;AAClD,MAAI,QAAQ,eAAgB,QAAO;EACnC,MAAM,YAAY,OAAO,KAAK,SAAS;EAEvC,MAAM,oBAAoB,CAAC,iBAAiB,wBAAwB;AACpE,MAAI,UAAU,WAAW,kBAAkB,OAAQ,QAAO;AAK1D,SAD0B,CAHQ,kBAAkB,OAAO,qBACzD,UAAU,SAAS,iBAAiB,CACrC;GAGD;AAEF,QAAO;;AAGT,IAAA,4BAAe"}

package/dist/knip.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"knip.js","names":[],"sources":["../src/knip.ts"],"sourcesContent":["import type { KnipConfig } from \"knip\"\n\nimport { createMergeConfigFn } from \"./utils.ts\"\n\n// Normally, specifying the `./src/index.ts` entry would cause knip to complain about a redundant entry because it gets automatically included via the tsdown plugin.\n// However, in projects that _don't_ use tsdown, the `./src/index.ts` entry would be missing entirely.\n// To handle this, we specify it and disable the tsdown plugin. This makes knip work in both cases.\n\nconst baseConfig = {\n  entry: [\"./src/index.ts\", \"**/*.test.ts\", \"./tsdown.config.ts\"],\n  project: [\"**\"],\n  tsdown: false,\n} as const satisfies KnipConfig\n\nexport const knipConfig = createMergeConfigFn<KnipConfig, typeof baseConfig>(baseConfig)\n"],"mappings":";AAcA,MAAa,aAAa,oBANP;CACjB,OAAO;EAAC;EAAkB;EAAgB;EAAqB;CAC/D,SAAS,CAAC,KAAK;CACf,QAAQ;CACT,CAEuF"}

package/dist/prettier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prettier.d.ts","names":[],"sources":["../src/prettier.ts"],"sourcesContent":[],"mappings":";;;;cAoCa;;;;IAAA,YAAA,CAAmF,EAAA,MAAA,GAAA,MAAA,EAAA;IAAA,OAAA,CAAA,EAAA,SAAA,CACwpP,OADxpP;;;;;;;;;EAArE,UAAA,CAAA,EAAA,MAAA"}

package/dist/prettier.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prettier.js","names":[],"sources":["../src/prettier.ts"],"sourcesContent":["import type { Config } from \"prettier\"\nimport type { Simplify } from \"type-fest\"\n\nimport { createMergeConfigFn } from \"./utils.ts\"\n\n// for some reason the Config type from prettier doesn't satisfy AnyObj unless we simplify it\ntype PrettierConfig = Simplify<Config>\n\nconst baseConfig = {\n  printWidth: 120,\n  semi: false,\n  plugins: [\n    \"@prettier/plugin-xml\",\n    \"prettier-plugin-sh\",\n    \"prettier-plugin-toml\",\n    \"prettier-plugin-astro\",\n    \"prettier-plugin-tailwindcss\",\n  ],\n  tailwindStylesheet: \"./src/global.css\",\n  overrides: [\n    {\n      // https://github.com/prettier/prettier/issues/15956\n      files: \"*.jsonc\",\n      options: {\n        trailingComma: \"none\",\n      },\n    },\n    {\n      files: \"*.astro\",\n      options: {\n        parser: \"astro\",\n      },\n    },\n  ],\n} as const satisfies PrettierConfig\n\nexport const prettierConfig = createMergeConfigFn<PrettierConfig, typeof baseConfig>(baseConfig)\n"],"mappings":";AAoCA,MAAa,iBAAiB,oBA5BX;CACjB,YAAY;CACZ,MAAM;CACN,SAAS;EACP;EACA;EACA;EACA;EACA;EACD;CACD,oBAAoB;CACpB,WAAW,CACT;EAEE,OAAO;EACP,SAAS,EACP,eAAe,QAChB;EACF,EACD;EACE,OAAO;EACP,SAAS,EACP,QAAQ,SACT;EACF,CACF;CACF,CAE+F"}