eleventy-plugin-vento 5.0.1 → 5.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/CHANGELOG.md +26 -0
  2. package/dist/plugin.d.ts +40 -38
  3. package/dist/plugin.js +182 -221
  4. package/package.json +8 -10
package/CHANGELOG.md CHANGED
@@ -1,5 +1,31 @@
1
1
  # eleventy-plugin-vento
2
2
 
3
+ ## 5.1.1
4
+
5
+ ### Patch Changes
6
+
7
+ - deadab6: Update Vento to v2.1.1
8
+
9
+ ## 5.1.0
10
+
11
+ ### Minor Changes
12
+
13
+ - d8813e4: Update Vento to v2.1.0
14
+
15
+ Vento 2.1.0 adds a [`strict`](https://vento.js.org/configuration/#strict-mode) mode to fail compilation if a variable is undefined. Because this option changes the performance profile of Vento, this plugin keeps it disabled (the default).
16
+
17
+ If you'd like to enable it, you can do so by setting it in the Vento config key when loading this plugin, like so:
18
+
19
+ ```js
20
+ eleventyConfig.addPlugin(VentoPlugin, {
21
+ ventoOptions: {
22
+ strict: true,
23
+ },
24
+ });
25
+ ```
26
+
27
+ See Vento's ([changelog](https://github.com/ventojs/vento/blob/main/CHANGELOG.md#210---2025-09-17)) for more information.
28
+
3
29
  ## 5.0.1
4
30
 
5
31
  ### Patch Changes
package/dist/plugin.d.ts CHANGED
@@ -1,42 +1,44 @@
1
- import UserConfig from '@11ty/eleventy/UserConfig';
2
- import { LiteralUnion } from 'type-fest';
3
- import * as ventojs from 'ventojs';
4
- import { Plugin } from 'ventojs/core/environment.js';
1
+ import * as ventojs from "ventojs";
2
+ import UserConfig from "@11ty/eleventy/UserConfig";
3
+ import { LiteralUnion } from "type-fest";
4
+ import { Plugin } from "ventojs/core/environment.js";
5
5
 
6
+ //#region src/types/options.d.ts
6
7
  interface PluginOptions {
7
- /**
8
- * An array of Vento plugins
9
- */
10
- plugins?: Plugin[];
11
- /**
12
- * Enables Vento's autotrim plugin.
13
- * ```js
14
- * // Set to an array of tags
15
- * autotrim: ['tag1', 'tag2']
16
- *
17
- * // Use Vento's defaults and Eleventy paired shortcodes
18
- * // If set to `true`, uses both
19
- * autotrim: ['@vento', '@11ty']
20
- * autotrim: true
21
- * ```
22
- */
23
- autotrim?: LiteralUnion<'@11ty' | '@vento', string>[] | boolean;
24
- /** Enable use of Eleventy filters */
25
- filters?: boolean;
26
- /** Enable use of Eleventy shortcodes */
27
- shortcodes?: boolean;
28
- /** Enable use of Eleventy paired shortcodes */
29
- pairedShortcodes?: boolean;
30
- /**
31
- * A Vento configuration object.
32
- *
33
- * **Note that `ventoOptions.includes` defaults to
34
- * Eleventy's own `dir.includes` location.**
35
- * @see {@link https://vento.js.org/configuration/}
36
- */
37
- ventoOptions?: ventojs.Options;
8
+ /**
9
+ * An array of Vento plugins
10
+ */
11
+ plugins?: Plugin[];
12
+ /**
13
+ * Enables Vento's autotrim plugin.
14
+ * ```js
15
+ * // Set to an array of tags
16
+ * autotrim: ['tag1', 'tag2']
17
+ *
18
+ * // Use Vento's defaults and Eleventy paired shortcodes
19
+ * // If set to `true`, uses both
20
+ * autotrim: ['@vento', '@11ty']
21
+ * autotrim: true
22
+ * ```
23
+ */
24
+ autotrim?: LiteralUnion<'@11ty' | '@vento', string>[] | boolean;
25
+ /** Enable use of Eleventy filters */
26
+ filters?: boolean;
27
+ /** Enable use of Eleventy shortcodes */
28
+ shortcodes?: boolean;
29
+ /** Enable use of Eleventy paired shortcodes */
30
+ pairedShortcodes?: boolean;
31
+ /**
32
+ * A Vento configuration object.
33
+ *
34
+ * **Note that `ventoOptions.includes` defaults to
35
+ * Eleventy's own `dir.includes` location.**
36
+ * @see {@link https://vento.js.org/configuration/}
37
+ */
38
+ ventoOptions?: ventojs.Options;
38
39
  }
39
-
40
+ //#endregion
41
+ //#region src/plugin.d.ts
40
42
  declare function VentoPlugin(eleventyConfig: UserConfig, userOptions: PluginOptions): void;
41
-
42
- export { VentoPlugin };
43
+ //#endregion
44
+ export { VentoPlugin };
package/dist/plugin.js CHANGED
@@ -1,241 +1,202 @@
1
- // src/plugin.ts
2
- import path from "path";
3
- import autotrimPlugin, { defaultTags as autotrimDefaultTags } from "ventojs/plugins/auto_trim.js";
4
-
5
- // src/engine.ts
1
+ import path from "node:path";
2
+ import autotrimPlugin, { defaultTags } from "ventojs/plugins/auto_trim.js";
6
3
  import createVentoEnv from "ventojs";
4
+ import createDebugger from "debug";
7
5
 
8
- // src/utils/create-vento-tag.ts
6
+ //#region src/utils/create-vento-tag.ts
9
7
  function createVentoTag(tagInfo) {
10
- let LEVEL = 1;
11
- const IS_PAIRED = tagInfo.group === "pairedShortcodes";
12
- const tag = (env, token, output, tokens) => {
13
- const code = token[1];
14
- const match = code === tagInfo.name || code.startsWith(`${tagInfo.name} `);
15
- if (!match) {
16
- return;
17
- }
18
- const { dataVarname } = env.options;
19
- const thisArg = `{
8
+ let LEVEL = 1;
9
+ const IS_PAIRED = tagInfo.group === "pairedShortcodes";
10
+ const tag = (env, token, output, tokens) => {
11
+ const code = token[1];
12
+ if (!(code === tagInfo.name || code.startsWith(`${tagInfo.name} `))) return;
13
+ const { dataVarname } = env.options;
14
+ const thisArg = `{
20
15
  page: ${dataVarname}.page,
21
16
  eleventy: ${dataVarname}.eleventy
22
17
  }`;
23
- const fn = `__env.utils.eleventyFunctions.${tagInfo.group}.${tagInfo.name}`;
24
- const args = [code.replace(tagInfo.name, "").trim()];
25
- const compiled = [];
26
- if (IS_PAIRED) {
27
- const nestedVarname = `__content${output.startsWith("__content") ? LEVEL++ : 0}`;
28
- args.unshift(env.compileFilters(tokens, nestedVarname, env.options.autoescape));
29
- compiled.push(
30
- "{",
31
- `let ${nestedVarname} = "";`,
32
- ...env.compileTokens(tokens, nestedVarname, `/${tagInfo.name}`)
33
- );
34
- }
35
- args.unshift(thisArg);
36
- compiled.push(
37
- "{",
38
- `const __result = await ${fn}.call(${args.filter(Boolean).join(", ")});`,
39
- `${output} += ${env.compileFilters(tokens, "__result", env.options.autoescape)}`,
40
- "}"
41
- );
42
- if (IS_PAIRED) {
43
- compiled.push("}");
44
- }
45
- return compiled.join("\n");
46
- };
47
- return Object.defineProperty(tag, "name", {
48
- value: `${tagInfo.name}_${IS_PAIRED ? `EleventyPairedTag` : `EleventyTag`}`
49
- });
18
+ const fn = `__env.utils.eleventyFunctions.${tagInfo.group}.${tagInfo.name}`;
19
+ const args = [code.replace(tagInfo.name, "").trim()];
20
+ const compiled = [];
21
+ if (IS_PAIRED) {
22
+ const nestedVarname = `__content${output.startsWith("__content") ? LEVEL++ : 0}`;
23
+ args.unshift(env.compileFilters(tokens, nestedVarname, env.options.autoescape));
24
+ compiled.push("{", `let ${nestedVarname} = "";`, ...env.compileTokens(tokens, nestedVarname, `/${tagInfo.name}`));
25
+ }
26
+ args.unshift(thisArg);
27
+ compiled.push("{", `const __result = await ${fn}.call(${args.filter(Boolean).join(", ")});`, `${output} += ${env.compileFilters(tokens, "__result", env.options.autoescape)}`, "}");
28
+ if (IS_PAIRED) compiled.push("}");
29
+ return compiled.join("\n");
30
+ };
31
+ return Object.defineProperty(tag, "name", { value: `${tagInfo.name}_${IS_PAIRED ? `EleventyPairedTag` : `EleventyTag`}` });
50
32
  }
51
33
 
52
- // src/utils/debuggers.ts
53
- import createDebugger from "debug";
54
- var debugBaseNamespace = "Eleventy:Vento";
55
- var debugMain = createDebugger(debugBaseNamespace);
56
- var debugCache = createDebugger(`${debugBaseNamespace}:Cache`);
57
- var debugRender = createDebugger(`${debugBaseNamespace}:Render`);
34
+ //#endregion
35
+ //#region src/utils/debuggers.ts
36
+ const debugBaseNamespace = "Eleventy:Vento";
37
+ const debugMain = createDebugger(debugBaseNamespace);
38
+ const debugCache = createDebugger(`${debugBaseNamespace}:Cache`);
39
+ const debugRender = createDebugger(`${debugBaseNamespace}:Render`);
58
40
 
59
- // src/engine.ts
41
+ //#endregion
42
+ //#region src/engine.ts
60
43
  function createVentoEngine(options) {
61
- const env = createVentoEnv(options);
62
- env.utils.eleventyFunctions = { shortcodes: {}, pairedShortcodes: {} };
63
- function loadPlugins(plugins) {
64
- for (const plugin of plugins) {
65
- env.use(plugin);
66
- }
67
- }
68
- function loadFilters(filters) {
69
- for (const [name, fn] of Object.entries(filters)) {
70
- env.filters[name] = function(...args) {
71
- const { page, eleventy } = this.data;
72
- return fn.apply({ ...this, page, eleventy }, args);
73
- };
74
- }
75
- }
76
- function loadShortcodes(shortcodes) {
77
- for (const [name, fn] of Object.entries(shortcodes)) {
78
- env.utils.eleventyFunctions.shortcodes[name] = fn;
79
- const shortcodeTag = createVentoTag({ name, group: "shortcodes" });
80
- env.tags.push(shortcodeTag);
81
- }
82
- }
83
- function loadPairedShortcodes(pairedShortcodes) {
84
- for (const [name, fn] of Object.entries(pairedShortcodes)) {
85
- env.utils.eleventyFunctions.pairedShortcodes[name] = fn;
86
- const shortcodeTag = createVentoTag({ name, group: "pairedShortcodes" });
87
- env.tags.push(shortcodeTag);
88
- }
89
- }
90
- async function getTemplateFunction(source, file, useVentoCache = true) {
91
- let template = await env.cache.get(file);
92
- if ((template == null ? void 0 : template.source) === source) {
93
- debugCache("Cache HIT for `%s`, used precompiled template", file);
94
- } else {
95
- template = env.compile(source, file);
96
- debugCache(
97
- `Cache MISS for \`%s\`, compiled new template; %s
98
-
99
- ${template}`,
100
- file,
101
- useVentoCache ? "let Vento cache result" : "defer result caching to Eleventy"
102
- );
103
- if (useVentoCache) {
104
- env.cache.set(file, template);
105
- }
106
- }
107
- return template;
108
- }
109
- return {
110
- cache: env.cache,
111
- loadPlugins,
112
- loadFilters,
113
- loadShortcodes,
114
- loadPairedShortcodes,
115
- getTemplateFunction
116
- };
44
+ const env = createVentoEnv(options);
45
+ env.utils.eleventyFunctions = {
46
+ shortcodes: {},
47
+ pairedShortcodes: {}
48
+ };
49
+ function loadPlugins(plugins) {
50
+ for (const plugin of plugins) env.use(plugin);
51
+ }
52
+ function loadFilters(filters) {
53
+ for (const [name, fn] of Object.entries(filters)) env.filters[name] = function(...args) {
54
+ const { page, eleventy } = this.data;
55
+ return fn.apply({
56
+ ...this,
57
+ page,
58
+ eleventy
59
+ }, args);
60
+ };
61
+ }
62
+ function loadShortcodes(shortcodes) {
63
+ for (const [name, fn] of Object.entries(shortcodes)) {
64
+ env.utils.eleventyFunctions.shortcodes[name] = fn;
65
+ const shortcodeTag = createVentoTag({
66
+ name,
67
+ group: "shortcodes"
68
+ });
69
+ env.tags.push(shortcodeTag);
70
+ }
71
+ }
72
+ function loadPairedShortcodes(pairedShortcodes) {
73
+ for (const [name, fn] of Object.entries(pairedShortcodes)) {
74
+ env.utils.eleventyFunctions.pairedShortcodes[name] = fn;
75
+ const shortcodeTag = createVentoTag({
76
+ name,
77
+ group: "pairedShortcodes"
78
+ });
79
+ env.tags.push(shortcodeTag);
80
+ }
81
+ }
82
+ async function getTemplateFunction(source, file, useVentoCache = true) {
83
+ let template = await env.cache.get(file);
84
+ if (template?.source === source) debugCache("Cache HIT for `%s`, used precompiled template", file);
85
+ else {
86
+ template = env.compile(source, file);
87
+ debugCache(`Cache MISS for \`%s\`, compiled new template; %s\n\n${template}`, file, useVentoCache ? "let Vento cache result" : "defer result caching to Eleventy");
88
+ if (useVentoCache) env.cache.set(file, template);
89
+ }
90
+ return template;
91
+ }
92
+ return {
93
+ cache: env.cache,
94
+ loadPlugins,
95
+ loadFilters,
96
+ loadShortcodes,
97
+ loadPairedShortcodes,
98
+ getTemplateFunction
99
+ };
117
100
  }
118
101
  async function renderVentoTemplate(template, data, from) {
119
- debugRender("Rendering `%s`", from);
120
- const { content } = await template(data);
121
- return content;
102
+ debugRender("Rendering `%s`", from);
103
+ const { content } = await template(data);
104
+ return content;
122
105
  }
123
106
 
124
- // src/utils/compat-check.ts
125
- var REQUIRED_API_METHODS = [
126
- ["getShortcodes", "v3.0.0-alpha.15"],
127
- ["getPairedShortcodes", "v3.0.0-alpha.15"],
128
- ["getFilters", "v3.0.0-alpha.15"],
129
- ["addExtension", "v1.0.0"]
107
+ //#endregion
108
+ //#region src/utils/compat-check.ts
109
+ const REQUIRED_API_METHODS = [
110
+ ["getShortcodes", "v3.0.0-alpha.15"],
111
+ ["getPairedShortcodes", "v3.0.0-alpha.15"],
112
+ ["getFilters", "v3.0.0-alpha.15"],
113
+ ["addExtension", "v1.0.0"]
130
114
  ];
131
115
  function compatibilityCheck(config) {
132
- debugMain("Run compatibility check");
133
- for (const [method, version] of REQUIRED_API_METHODS) {
134
- if (!(method in config)) {
135
- console.error(
136
- "[eleventy-plugin-vento] Plugin compatibility error:",
137
- `\`${method}\``,
138
- "not found. Please use Eleventy",
139
- version,
140
- "or later."
141
- );
142
- }
143
- }
116
+ debugMain("Run compatibility check");
117
+ for (const [method, version] of REQUIRED_API_METHODS) if (!(method in config)) console.error("[eleventy-plugin-vento] Plugin compatibility error:", `\`${method}\``, "not found. Please use Eleventy", version, "or later.");
144
118
  }
145
119
 
146
- // src/plugin.ts
120
+ //#endregion
121
+ //#region src/plugin.ts
147
122
  function VentoPlugin(eleventyConfig, userOptions) {
148
- debugMain("Initializing eleventy-plugin-vento");
149
- compatibilityCheck(eleventyConfig);
150
- const options = {
151
- // Define defaults
152
- autotrim: false,
153
- plugins: [],
154
- filters: true,
155
- shortcodes: true,
156
- pairedShortcodes: true,
157
- ventoOptions: {
158
- includes: eleventyConfig.directories.includes
159
- },
160
- // Merge in user-provided options
161
- ...userOptions
162
- };
163
- debugMain("Merged default and user config: %O", options);
164
- const filters = eleventyConfig.getFilters();
165
- debugMain("Reading filters from Eleventy: %o", filters);
166
- const shortcodes = eleventyConfig.getShortcodes();
167
- debugMain("Reading shortcodes from Eleventy: %o", shortcodes);
168
- const pairedShortcodes = eleventyConfig.getPairedShortcodes();
169
- debugMain("Reading paired shortcodes from Eleventy: %o", pairedShortcodes);
170
- if (options.autotrim) {
171
- const defaults = ["@vento", "@11ty"];
172
- const tagSet = new Set(options.autotrim === true ? defaults : options.autotrim);
173
- if (tagSet.has("@vento")) {
174
- tagSet.delete("@vento");
175
- for (const name of autotrimDefaultTags) {
176
- tagSet.add(name);
177
- }
178
- }
179
- if (tagSet.has("@11ty")) {
180
- tagSet.delete("@11ty");
181
- for (const name in pairedShortcodes) {
182
- tagSet.add(name);
183
- }
184
- }
185
- debugMain("Enabled autotrim for tags: %o", tagSet);
186
- options.plugins.push(autotrimPlugin({ tags: [...tagSet] }));
187
- }
188
- debugMain("Initializing Vento environment");
189
- const engine = createVentoEngine(options.ventoOptions);
190
- debugMain("Loading plugins: %o", options.plugins);
191
- engine.loadPlugins(options.plugins);
192
- if (options.filters) {
193
- debugMain("Loading filters: %o", filters);
194
- engine.loadFilters(filters);
195
- }
196
- if (options.shortcodes) {
197
- debugMain("Loading shortcodes: %o", shortcodes);
198
- engine.loadShortcodes(shortcodes);
199
- }
200
- if (options.pairedShortcodes) {
201
- debugMain("Loading paired shortcodes: %o", pairedShortcodes);
202
- engine.loadPairedShortcodes(pairedShortcodes);
203
- }
204
- debugMain("Registering Vento cache handler on eleventy.beforeWatch event");
205
- eleventyConfig.on("eleventy.beforeWatch", async (updatedFiles) => {
206
- for (let file of updatedFiles) {
207
- file = path.normalize(file);
208
- debugCache("Delete cache entry for %s", file);
209
- engine.cache.delete(file);
210
- }
211
- });
212
- debugMain("Registering .vto as a template format");
213
- eleventyConfig.addTemplateFormats("vto");
214
- debugMain("Registering .vto extension with eleventy");
215
- eleventyConfig.addExtension("vto", {
216
- outputFileExtension: "html",
217
- read: true,
218
- async compile(inputContent, inputPath) {
219
- inputPath = path.normalize(inputPath);
220
- debugMain("Getting template function for `%s`", inputPath);
221
- const template = await engine.getTemplateFunction(inputContent, inputPath, false);
222
- return async (data) => await renderVentoTemplate(template, data, inputPath);
223
- },
224
- compileOptions: {
225
- // Custom permalink compilation
226
- async permalink(permalinkContent, inputPath) {
227
- if (typeof permalinkContent !== "string" || !/\{\{\s+.+\s+\}\}/.test(permalinkContent)) {
228
- return permalinkContent;
229
- }
230
- inputPath = "Permalink::" + path.normalize(inputPath);
231
- debugMain("Getting template function for `%s`", inputPath);
232
- const template = await engine.getTemplateFunction(permalinkContent, inputPath);
233
- return async (data) => await renderVentoTemplate(template, data, inputPath);
234
- }
235
- }
236
- });
237
- debugMain("eleventy-plugin-vento initialized");
123
+ debugMain("Initializing eleventy-plugin-vento");
124
+ compatibilityCheck(eleventyConfig);
125
+ const options = {
126
+ autotrim: false,
127
+ plugins: [],
128
+ filters: true,
129
+ shortcodes: true,
130
+ pairedShortcodes: true,
131
+ ventoOptions: { includes: eleventyConfig.directories.includes },
132
+ ...userOptions
133
+ };
134
+ debugMain("Merged default and user config: %O", options);
135
+ const filters = eleventyConfig.getFilters();
136
+ debugMain("Reading filters from Eleventy: %o", filters);
137
+ const shortcodes = eleventyConfig.getShortcodes();
138
+ debugMain("Reading shortcodes from Eleventy: %o", shortcodes);
139
+ const pairedShortcodes = eleventyConfig.getPairedShortcodes();
140
+ debugMain("Reading paired shortcodes from Eleventy: %o", pairedShortcodes);
141
+ if (options.autotrim) {
142
+ const tagSet = new Set(options.autotrim === true ? ["@vento", "@11ty"] : options.autotrim);
143
+ if (tagSet.has("@vento")) {
144
+ tagSet.delete("@vento");
145
+ for (const name of defaultTags) tagSet.add(name);
146
+ }
147
+ if (tagSet.has("@11ty")) {
148
+ tagSet.delete("@11ty");
149
+ for (const name in pairedShortcodes) tagSet.add(name);
150
+ }
151
+ debugMain("Enabled autotrim for tags: %o", tagSet);
152
+ options.plugins.push(autotrimPlugin({ tags: [...tagSet] }));
153
+ }
154
+ debugMain("Initializing Vento environment");
155
+ const engine = createVentoEngine(options.ventoOptions);
156
+ debugMain("Loading plugins: %o", options.plugins);
157
+ engine.loadPlugins(options.plugins);
158
+ if (options.filters) {
159
+ debugMain("Loading filters: %o", filters);
160
+ engine.loadFilters(filters);
161
+ }
162
+ if (options.shortcodes) {
163
+ debugMain("Loading shortcodes: %o", shortcodes);
164
+ engine.loadShortcodes(shortcodes);
165
+ }
166
+ if (options.pairedShortcodes) {
167
+ debugMain("Loading paired shortcodes: %o", pairedShortcodes);
168
+ engine.loadPairedShortcodes(pairedShortcodes);
169
+ }
170
+ debugMain("Registering Vento cache handler on eleventy.beforeWatch event");
171
+ eleventyConfig.on("eleventy.beforeWatch", async (updatedFiles) => {
172
+ for (let file of updatedFiles) {
173
+ file = path.normalize(file);
174
+ debugCache("Delete cache entry for %s", file);
175
+ engine.cache.delete(file);
176
+ }
177
+ });
178
+ debugMain("Registering .vto as a template format");
179
+ eleventyConfig.addTemplateFormats("vto");
180
+ debugMain("Registering .vto extension with eleventy");
181
+ eleventyConfig.addExtension("vto", {
182
+ outputFileExtension: "html",
183
+ read: true,
184
+ async compile(inputContent, inputPath) {
185
+ inputPath = path.normalize(inputPath);
186
+ debugMain("Getting template function for `%s`", inputPath);
187
+ const template = await engine.getTemplateFunction(inputContent, inputPath, false);
188
+ return async (data) => await renderVentoTemplate(template, data, inputPath);
189
+ },
190
+ compileOptions: { async permalink(permalinkContent, inputPath) {
191
+ if (typeof permalinkContent !== "string" || !/\{\{\s+.+\s+\}\}/.test(permalinkContent)) return permalinkContent;
192
+ inputPath = "Permalink::" + path.normalize(inputPath);
193
+ debugMain("Getting template function for `%s`", inputPath);
194
+ const template = await engine.getTemplateFunction(permalinkContent, inputPath);
195
+ return async (data) => await renderVentoTemplate(template, data, inputPath);
196
+ } }
197
+ });
198
+ debugMain("eleventy-plugin-vento initialized");
238
199
  }
239
- export {
240
- VentoPlugin
241
- };
200
+
201
+ //#endregion
202
+ export { VentoPlugin };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "eleventy-plugin-vento",
3
- "version": "5.0.1",
3
+ "version": "5.1.1",
4
4
  "description": "Adds support for the Vento templating language to Eleventy.",
5
5
  "type": "module",
6
6
  "engines": {
@@ -37,7 +37,7 @@
37
37
  "license": "MIT",
38
38
  "dependencies": {
39
39
  "debug": "4.4.3",
40
- "ventojs": "2.0.2"
40
+ "ventojs": "2.1.1"
41
41
  },
42
42
  "devDependencies": {
43
43
  "11ty.ts": "0.0.6",
@@ -52,9 +52,8 @@
52
52
  "globals": "16.4.0",
53
53
  "knip": "5.63.1",
54
54
  "prettier": "3.6.2",
55
- "tsup": "8.5.0",
56
- "tsx": "4.20.5",
57
- "type-fest": "4.41.0",
55
+ "tsdown": "0.15.4",
56
+ "type-fest": "5.0.0",
58
57
  "typescript": "5.9.2",
59
58
  "typescript-eslint": "8.43.0",
60
59
  "vitest": "3.2.4"
@@ -65,11 +64,10 @@
65
64
  "lint:syntax": "eslint '.'",
66
65
  "lint:types": "tsc --noEmit",
67
66
  "lint:project": "knip",
68
- "build": "tsup",
69
- "dev": "tsup --watch ./src",
70
- "ci:version": "changeset version && pnpm install --no-frozen-lockfile",
71
- "ci:publish": "changeset publish",
72
- "ci:generate-renovate-changesets": "tsx .github/scripts/renovate-changesets.ts",
67
+ "build": "tsdown",
68
+ "dev": "tsdown --watch ./src",
69
+ "ci:version": "changeset version",
70
+ "ci:publish": "npm audit signatures && changeset publish",
73
71
  "fmt": "prettier --write ."
74
72
  }
75
73
  }