@ben_12/eslint-plugin-dprint 1.20.0 → 1.21.1

package/README.md

@@ -123,6 +123,96 @@ module.exports = {
 
 Then run ESLint with `--fix`!
 
+### Providing a pre-resolved formatter via `settings`
+
+By default the plugin loads each dprint formatter at module-load time by doing a dynamic `require()`
+of the corresponding peer package (`@dprint/typescript`, `dprint-plugin-yaml`, …). That works for
+most setups, but it relies on the optional peer dependency being installed _and_ discoverable by
+Node's resolver. Some bundlers and bundled config packages (anything that does static module-graph
+analysis, e.g. [Packtory](https://github.com/lukas-bischof/packtory)) only follow real `import`
+statements, so the dprint plugins never end up in the bundle. In that case the plugin logs
+`Plugin not found: …` for every linted file and the rule silently becomes a no-op.
+
+You can avoid this by passing a pre-resolved formatter through ESLint's `settings`. Settings are not
+serialized or `structuredClone`d by ESLint, so they can carry runtime objects (modules, buffers,
+pre-built formatters). When a formatter is provided this way, the plugin uses it directly and skips
+the dynamic `require()` lookup (and the associated "Plugin not found" warning).
+
+Accepted shapes for each formatter entry:
+
+- an object with `getPath(): string` (the shape exported by `@dprint/typescript`, `@dprint/json`,
+  `@dprint/markdown`, `@dprint/toml`, `@dprint/dockerfile`)
+- an object with `getBuffer(): Buffer | Uint8Array` (legacy shape, previously used by some
+  `@dprint/*` packages)
+- a raw `Buffer` / `Uint8Array` / `ArrayBuffer` of the plugin's wasm bytes
+- a pre-built `Formatter` returned by `@dprint/formatter`'s `createFromBuffer`
+
+Example (flat config):
+
+```mjs
+import { defineConfig } from "eslint/config";
+import dprint from "@ben_12/eslint-plugin-dprint";
+import typescriptFormatter from "@dprint/typescript";
+
+export default defineConfig([
+  {
+    files: ["**/*.ts"],
+    plugins: { "@ben_12/dprint": dprint },
+    settings: {
+      "@ben_12/dprint": {
+        formatters: {
+          typescript: typescriptFormatter,
+        },
+      },
+    },
+    rules: {
+      "@ben_12/dprint/typescript": ["error", { config: { /* dprint config */ } }],
+    },
+  },
+]);
+```
+
+The settings key is the plugin namespace (`@ben_12/dprint`). Inside `formatters`, the key is the
+rule name (`typescript`, `json`, `markdown`, `toml`, `dockerfile`, `malva`, `markup`, `yaml`,
+`graphql`).
+
+#### g-plane plugins (`yaml`, `malva`, `markup`, `graphql`)
+
+The `@dprint/*` packages can be imported and passed straight through, as in the example above.
+The g-plane packages (`dprint-plugin-yaml`, `dprint-plugin-malva`, `dprint-plugin-markup`,
+`dprint-plugin-graphql`) have no JS entrypoint and ship only `plugin.wasm`, so callers have to
+resolve and read the wasm file themselves and pass the result through `createFromBuffer` (or as
+a raw `BufferSource`). Example for `dprint-plugin-graphql`:
+
+```mjs
+import { defineConfig } from "eslint/config";
+import dprint from "@ben_12/eslint-plugin-dprint";
+import { createFromBuffer } from "@dprint/formatter";
+import fs from "node:fs";
+
+const graphqlFormatter = createFromBuffer(
+  fs.readFileSync(new URL(import.meta.resolve("dprint-plugin-graphql/plugin.wasm"))),
+);
+
+export default defineConfig([
+  {
+    files: ["**/*.graphql"],
+    plugins: { "@ben_12/dprint": dprint },
+    settings: {
+      "@ben_12/dprint": {
+        formatters: { graphql: graphqlFormatter },
+      },
+    },
+    rules: {
+      "@ben_12/dprint/graphql": ["error", { config: { /* dprint config */ } }],
+    },
+  },
+]);
+```
+
+The same pattern (with the matching package and rule name) applies to `yaml`, `malva`, and
+`markup`.
+
 For unparsed eslint file like markdown or dockerfile, you can use [@ben_12/eslint-simple-parser](https://www.npmjs.com/package/@ben_12/eslint-simple-parser) as parser.
 
 ```mjs

package/dist/lib/dprint/dprint.d.ts

@@ -1,10 +1,37 @@
-import { FormatRequest } from "@dprint/formatter";
+import { FormatRequest, Formatter } from "@dprint/formatter";
+/**
+ * Caller-provided formatter, used as the pre-resolved bypass of the module-level
+ * plugin lookup. The `@dprint/*` packages expose `getPath()` and can be passed directly;
+ * the `g-plane` packages (`dprint-plugin-yaml`, `-malva`, `-markup`, `-graphql`) ship
+ * only `plugin.wasm` with no JS entrypoint, so callers must read the wasm file and
+ * pass the buffer (or a pre-built `Formatter`) instead.
+ *
+ * Supported shapes:
+ *  - `{ getPath(): string }`: shape exported by current `@dprint/*` plugin packages
+ *  - `{ getBuffer(): BufferSource }`: legacy shape, used by older `@dprint/*` versions
+ *  - raw wasm bytes (`Buffer` / `Uint8Array` / `ArrayBuffer`)
+ *  - a pre-built `Formatter` from `@dprint/formatter`'s `createFromBuffer`
+ */
+export type FormatterInput = {
+    getPath(): string;
+} | {
+    getBuffer(): BufferSource;
+} | BufferSource | Formatter;
 /**
  * Format the given text with the given config.
- * @param config The config object.
+ * @param configFile Path to a dprint configuration file (or empty string for none).
+ * @param overrideConfig Inline config for the originating plugin (applied per-call via FormatRequest.overrideConfig).
+ * @param hostConfigs Per-sibling-plugin config. Merged into FormatRequest.overrideConfig on each
+ *   delegated call when the originating plugin invokes a sibling via the host callback
+ *   (e.g. fenced code blocks inside markdown). Keys are plugin names ("typescript", "json", ...).
+ *   Without this, host-invoked plugins fall back to the on-disk configFile only.
  * @param filePath The path to the file.
  * @param fileText The content of the file.
- * @returns The formatted text or undefined. It's undefined if the formatter doesn't change the text.
+ * @param configName The plugin name of the originating formatter.
+ * @param formatterInput Optional pre-resolved dprint formatter (or its source) to use instead of the
+ *   module-level plugin lookup. When supplied, the global formatter table is bypassed and no
+ *   "Plugin not found" warning is logged.
+ * @returns The formatted text. Returns the input fileText if no formatter applies.
  */
-export declare function format(configFile: string, overrideConfig: Record<string, unknown>, filePath: string, fileText: string, configName: string): string;
-export declare function formatWithHost(request: FormatRequest, configFile: string, fromConfigName: string): string;
+export declare function format(configFile: string, overrideConfig: Record<string, unknown>, hostConfigs: Record<string, Record<string, unknown>>, filePath: string, fileText: string, configName: string, formatterInput?: FormatterInput): string;
+export declare function formatWithHost(request: FormatRequest, configFile: string, hostConfigs: Record<string, Record<string, unknown>>, fromConfigName: string): string;

package/dist/lib/dprint/dprint.js

@@ -99,16 +99,57 @@ const formatters = Object.entries(plugins).reduce((formatters, [name, getBuffer]
     }
     return formatters;
 }, {});
-/** Cache to reduce copies of config values. */
-const lastConfigFile = {};
-function getFormatter(filePath, configName, configFile, log = true) {
-    const formatter = formatters[configName];
-    if (formatter) {
+function isBufferSource(value) {
+    return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+function isFormatter(value) {
+    return typeof value === "object" && value !== null &&
+        typeof value.formatText === "function" &&
+        typeof value.getPluginInfo === "function" &&
+        typeof value.setConfig === "function";
+}
+/** Cache of resolved Formatters keyed by the caller-provided FormatterInput identity. */
+const resolvedFormatters = new WeakMap();
+function resolveFormatterInput(input) {
+    const cached = resolvedFormatters.get(input);
+    if (cached) {
+        return cached;
+    }
+    let formatter;
+    if (isFormatter(input)) {
+        formatter = input;
+    }
+    else if (isBufferSource(input)) {
+        formatter = (0, formatter_1.createFromBuffer)(input);
+    }
+    else if (typeof input.getPath === "function") {
+        formatter = (0, formatter_1.createFromBuffer)(Buffer.from(fs.readFileSync(input.getPath())));
+    }
+    else if (typeof input.getBuffer === "function") {
+        formatter = (0, formatter_1.createFromBuffer)(input.getBuffer());
+    }
+    else {
+        throw new TypeError("Invalid `formatter` option: expected a Formatter, BufferSource, " +
+            "or an object with getPath()/getBuffer().");
+    }
+    resolvedFormatters.set(input, formatter);
+    return formatter;
+}
+/** Cache of the last configFile applied to a given Formatter, to avoid redundant setConfig calls. */
+const lastConfigFileByFormatter = new WeakMap();
+function applyConfigIfNeeded(formatter, configFile) {
+    if (lastConfigFileByFormatter.get(formatter) !== configFile) {
+        lastConfigFileByFormatter.set(formatter, configFile);
         const configKey = formatter.getPluginInfo().configKey;
-        if (configFile !== lastConfigFile[configKey]) {
-            lastConfigFile[configKey] = configFile;
-            setConfig(formatter, configKey, configFile);
-        }
+        setConfig(formatter, configKey, configFile);
+    }
+}
+function getFormatter(filePath, configName, configFile, log, formatterInput) {
+    const formatter = formatterInput === undefined
+        ? formatters[configName]
+        : resolveFormatterInput(formatterInput);
+    if (formatter) {
+        applyConfigIfNeeded(formatter, configFile);
         const fileMatchingInfo = formatter.getFileMatchingInfo();
         const fileExtensions = fileMatchingInfo.fileExtensions || [];
         const fileNames = fileMatchingInfo.fileNames || [];
@@ -131,37 +172,52 @@ function getFormatter(filePath, configName, configFile, log = true) {
 function getFormatterByExt(filePath, configFile, exclude) {
     const configNames = Object.keys(formatters).filter(name => name !== exclude);
     for (const configName of configNames) {
-        const formatter = getFormatter(filePath, configName, configFile, false);
+        const formatter = getFormatter(filePath, configName, configFile, false, undefined);
         if (formatter) {
-            return [configFile, formatter];
+            return [configName, formatter];
         }
     }
     return [];
 }
 /**
  * Format the given text with the given config.
- * @param config The config object.
+ * @param configFile Path to a dprint configuration file (or empty string for none).
+ * @param overrideConfig Inline config for the originating plugin (applied per-call via FormatRequest.overrideConfig).
+ * @param hostConfigs Per-sibling-plugin config. Merged into FormatRequest.overrideConfig on each
+ *   delegated call when the originating plugin invokes a sibling via the host callback
+ *   (e.g. fenced code blocks inside markdown). Keys are plugin names ("typescript", "json", ...).
+ *   Without this, host-invoked plugins fall back to the on-disk configFile only.
  * @param filePath The path to the file.
  * @param fileText The content of the file.
- * @returns The formatted text or undefined. It's undefined if the formatter doesn't change the text.
+ * @param configName The plugin name of the originating formatter.
+ * @param formatterInput Optional pre-resolved dprint formatter (or its source) to use instead of the
+ *   module-level plugin lookup. When supplied, the global formatter table is bypassed and no
+ *   "Plugin not found" warning is logged.
+ * @returns The formatted text. Returns the input fileText if no formatter applies.
  */
-function format(configFile, overrideConfig, filePath, fileText, configName) {
-    const formatter = getFormatter(filePath, configName, configFile);
+function format(configFile, overrideConfig, hostConfigs, filePath, fileText, configName, formatterInput) {
+    const formatter = getFormatter(filePath, configName, configFile, true, formatterInput);
     if (formatter) {
         const request = {
             filePath,
             fileText,
             overrideConfig,
         };
-        return formatter.formatText(request, hostRequest => formatWithHost(hostRequest, configFile, configName));
+        return formatter.formatText(request, hostRequest => formatWithHost(hostRequest, configFile, hostConfigs, configName));
     }
     return fileText;
 }
 exports.format = format;
-function formatWithHost(request, configFile, fromConfigName) {
+function formatWithHost(request, configFile, hostConfigs, fromConfigName) {
     const [configName, formatter] = getFormatterByExt(request.filePath, configFile, fromConfigName);
     if (configName && formatter) {
-        return formatter.formatText(request, hostRequest => formatWithHost(hostRequest, configFile, configName));
+        const hostConfig = hostConfigs[configName];
+        if (hostConfig && typeof hostConfig === "object") {
+            const overrideConfig = { ...request.overrideConfig };
+            extractConfig(hostConfig, overrideConfig);
+            request = { ...request, overrideConfig };
+        }
+        return formatter.formatText(request, hostRequest => formatWithHost(hostRequest, configFile, hostConfigs, configName));
     }
     return request.fileText;
 }

package/dist/lib/rules/dprint.d.ts

@@ -1,4 +1,24 @@
 import { Rule } from "eslint";
+import { FormatterInput } from "../dprint/dprint";
+/**
+ * Shape of the per-plugin entry under ESLint's `settings`.
+ *
+ * Example:
+ *   settings: {
+ *     "@ben_12/dprint": {
+ *       formatters: { typescript: require("@dprint/typescript") },
+ *     },
+ *   }
+ *
+ * `settings` is deep-merged without being structured-cloned, so the formatter values
+ * can be runtime objects (modules, pre-built Formatters, raw buffers) — see
+ * `FormatterInput` in lib/dprint/dprint.ts.
+ */
+export interface DprintPluginSettings {
+    readonly formatters?: {
+        readonly [ruleName: string]: FormatterInput | undefined;
+    };
+}
 export declare const dprintRules: {
     [name: string]: Rule.RuleModule;
 };

package/dist/lib/rules/dprint.js

@@ -173,59 +173,85 @@ function createMessage(d) {
         createMoveMessage(d) ||
         createRepaceMessage(d);
 }
-const defaultOptions = { configFile: "dprint.json", config: {} };
-exports.dprintRules = configSchemas.map((config) => ({
-    [config.name]: {
-        meta: {
-            docs: {
-                description: `Format ${config.name} with dprint`,
-                url: `https://github.com/ben12/eslint-plugin-dprint/blob/master/docs/rules/dprint-${config.name}.md`,
-                recommended: true,
-            },
-            fixable: "code",
-            messages,
-            schema: {
-                definitions: config.configSchema.definitions,
-                type: "array",
-                items: [{
-                        type: "object",
-                        properties: {
-                            configFile: {
-                                type: "string",
-                                default: "dprint.json",
-                                description: "dprint configuration file (default 'dprint.json')",
-                            },
-                            config: {
-                                type: "object",
-                                properties: config.configSchema.properties,
-                                additionalProperties: false,
+const defaultOptions = { configFile: "dprint.json", config: {}, hostConfigs: {} };
+const SETTINGS_KEY = "@ben_12/dprint";
+function readFormatterFromSettings(settings, ruleName) {
+    const pluginSettings = (settings?.[SETTINGS_KEY] ?? undefined);
+    return pluginSettings?.formatters?.[ruleName];
+}
+exports.dprintRules = configSchemas.map((config) => {
+    // Allow per-sibling-plugin config to flow into setConfig for host-invoked formatters
+    // (e.g. fenced code blocks inside markdown). Keys are sibling plugin names; the current
+    // plugin is excluded because its own config already goes through `config`/overrideConfig.
+    // Inner values are not strictly validated by schema — dprint's WASM setConfig handles that.
+    const hostConfigsProperties = configSchemas.reduce((acc, sibling) => {
+        if (sibling.name !== config.name) {
+            acc[sibling.name] = { type: "object", additionalProperties: true };
+        }
+        return acc;
+    }, {});
+    return {
+        [config.name]: {
+            meta: {
+                docs: {
+                    description: `Format ${config.name} with dprint`,
+                    url: `https://github.com/ben12/eslint-plugin-dprint/blob/master/docs/rules/dprint-${config.name}.md`,
+                    recommended: true,
+                },
+                fixable: "code",
+                messages,
+                schema: {
+                    definitions: config.configSchema.definitions,
+                    type: "array",
+                    items: [{
+                            type: "object",
+                            properties: {
+                                configFile: {
+                                    type: "string",
+                                    default: "dprint.json",
+                                    description: "dprint configuration file (default 'dprint.json')",
+                                },
+                                config: {
+                                    type: "object",
+                                    properties: config.configSchema.properties,
+                                    additionalProperties: false,
+                                },
+                                hostConfigs: {
+                                    type: "object",
+                                    properties: hostConfigsProperties,
+                                    additionalProperties: false,
+                                    description: "Config applied to sibling plugins when this plugin delegates to them " +
+                                        "(e.g. fenced code blocks). Keys are sibling plugin names.",
+                                },
                             },
-                        },
-                        additionalProperties: false,
-                    }],
-                additionalItems: false,
+                            additionalProperties: false,
+                        }],
+                    additionalItems: false,
+                },
+                type: "layout",
             },
-            type: "layout",
+            create: (context) => ({
+                Program() {
+                    const sourceCode = context.sourceCode ?? context.getSourceCode();
+                    const filePath = context.filename ?? context.getFilename();
+                    const fileText = sourceCode.getText();
+                    const options = context.options[0] ?? defaultOptions;
+                    const configFile = options.configFile ?? "dprint.json";
+                    const configOpt = options.config || {};
+                    const hostConfigs = options.hostConfigs || {};
+                    // Needs an absolute path
+                    if (!filePath || !node_path_1.default.isAbsolute(filePath)) {
+                        return;
+                    }
+                    // Does format
+                    const formatterInput = readFormatterFromSettings(context.settings, config.name);
+                    const formattedText = (0, dprint_1.format)(configFile, configOpt, hostConfigs, filePath, fileText, config.name, formatterInput);
+                    generateLintReports(fileText, formattedText, sourceCode, context);
+                },
+            }),
         },
-        create: (context) => ({
-            Program() {
-                const sourceCode = context.sourceCode ?? context.getSourceCode();
-                const filePath = context.filename ?? context.getFilename();
-                const fileText = sourceCode.getText();
-                const options = context.options[0] ?? defaultOptions;
-                const configFile = options.configFile ?? "dprint.json";
-                const configOpt = options.config || {};
-                // Needs an absolute path
-                if (!filePath || !node_path_1.default.isAbsolute(filePath)) {
-                    return;
-                }
-                // Does format
-                const formattedText = (0, dprint_1.format)(configFile, configOpt, filePath, fileText, config.name);
-                generateLintReports(fileText, formattedText, sourceCode, context);
-            },
-        }),
-    },
-})).reduce((r1, r2) => ({ ...r1, ...r2 }), {});
+    };
+}).reduce((r1, r2) => ({ ...r1, ...r2 }), {});
 function generateLintReports(fileText, formattedText, sourceCode, context) {
     for (const d of difference_iterator_1.DifferenceIterator.iterate(fileText, formattedText)) {
         const loc = d.type === "add"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ben_12/eslint-plugin-dprint",
-  "version": "1.20.0",
+  "version": "1.21.1",
   "description": "An ESLint plugin that fixes code with dprint",
   "engines": {
     "node": ">=18.0.0"
@@ -18,7 +18,7 @@
     "@dprint/typescript": "^0.96.1",
     "dprint-plugin-graphql": "^0.2.3",
     "dprint-plugin-malva": "^0.16.0",
-    "dprint-plugin-markup": "^0.27.2",
+    "dprint-plugin-markup": "^0.27.3",
     "dprint-plugin-yaml": "^0.6.0",
     "eslint": ">=7.0.0"
   },
@@ -72,7 +72,7 @@
     "axios": "^1.7.9",
     "dprint-plugin-graphql": "^0.2.3",
     "dprint-plugin-malva": "^0.16.0",
-    "dprint-plugin-markup": "^0.27.2",
+    "dprint-plugin-markup": "^0.27.3",
     "dprint-plugin-yaml": "^0.6.0",
     "eslint": "^9.0.0",
     "mocha": "^11.0.0",