Introduce new option allowWriteFilesInBuild. (#35)

.gitignore

@@ -27,3 +27,4 @@ node_modules/
 .idea
 
 dist
+src/fixtures/webfont-test/artifacts/*

README.md

@@ -268,6 +268,12 @@ The plugin has an API consisting of one required parameter and multiple optional
 -   **description**: Inline font assets in CSS using base64 encoding.
 -   **default** `false`
 
+### allowWriteFilesInBuild
+
+-   **type**: `boolean`
+-   **description**: Allow outputting assets (HTML, CSS, and Fonts) during build. [see](https://github.com/atlowChemi/vite-svg-2-webfont/issues/32#issuecomment-2203187501)
+-   **default** `false`
+
 ## Public API
 
 The plugin exposes a public API that can be used inside another plugins using [Rollup inter-plugin communication mechanism](https://rollupjs.org/plugin-development/#inter-plugin-communication).

src/fixtures/vite.allowWriteFilesInBuild.config.ts

@@ -0,0 +1,21 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+import { viteSvgToWebfont } from '../../';
+
+const webfontFolder = resolve(__dirname, './webfont-test/svg');
+const outputFolder = resolve(__dirname, './webfont-test/artifacts');
+
+export default defineConfig({
+    build: {
+        assetsInlineLimit: 0,
+    },
+    plugins: [
+        viteSvgToWebfont({
+            dest: outputFolder,
+            generateFiles: true,
+            context: webfontFolder,
+            allowWriteFilesInBuild: true,
+            fontName: 'allowWriteFilesInBuild-test',
+        }),
+    ],
+});

src/index.test.ts

@@ -1,5 +1,6 @@
-import { fileURLToPath } from 'url';
-import { readFile } from 'fs/promises';
+import { constants } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { readFile, access, rmdir } from 'node:fs/promises';
 import { describe, it, beforeAll, afterAll, expect } from 'vitest';
 import { build, createServer, preview, normalizePath } from 'vite';
 import type { RollupOutput } from 'rollup';
@@ -16,6 +17,7 @@ const fileURLToNormalizedPath = (url: URL) => normalizePath(fileURLToPath(url));
 const enum ConfigType {
     Basic = './vite.basic.config.ts',
     NoInline = './vite.no-inline.config.ts',
+    AllowWriteFilesInBuild = './vite.allowWriteFilesInBuild.config.ts',
 }
 const getConfig = (configType: ConfigType): InlineConfig => ({
     logLevel: 'silent',
@@ -181,10 +183,30 @@ describe('build:no-inline', () => {
     });
 
     types.forEach(type => {
-        it.concurrent(`has font of type ${type} available`, async () => {
+        it.concurrent.each(types)('has font of type %s available', async () => {
             const iconAssetName = output.find(({ fileName }) => fileName.startsWith('assets/iconfont-') && fileName.endsWith(type))!.fileName;
             const [expected, res] = await Promise.all([loadFileContent(`fonts/iconfont.${type}`, 'buffer'), fetchBufferContent(server, `/${iconAssetName}`)]);
             expect(res).toStrictEqual(expected);
         });
     });
 });
+
+describe('build allowWriteFilesInBuild', () => {
+    const buildConfig = getConfig(ConfigType.AllowWriteFilesInBuild);
+
+    beforeAll(async () => {
+        await build(buildConfig);
+    });
+
+    afterAll(async () => {
+        await rmdir(new URL('webfont-test/artifacts', root), { recursive: true });
+    });
+
+    it.concurrent.each([...types, 'html', 'css'])('has generated font of type %s', async type => {
+        const fileName = `webfont-test/artifacts/allowWriteFilesInBuild-test.${type}`;
+        const fileNameCasing = types.includes(type) ? fileName : fileName.toLowerCase();
+        const filePath = new URL(fileNameCasing, root);
+
+        await expect(access(filePath, constants.F_OK)).resolves.not.toThrow();
+    });
+});

src/index.ts

@@ -55,20 +55,16 @@ export function viteSvgToWebfont<T extends GeneratedFontTypes = GeneratedFontTyp
         if (updateFiles) {
             processedOptions.files = parseFiles(options);
         }
-        if (isBuild) {
+        if (isBuild && !options.allowWriteFilesInBuild) {
             processedOptions.writeFiles = false;
         }
         generatedFonts = await webfontGenerator(processedOptions);
         const hasFilesToSave = !processedOptions.writeFiles && (processedOptions.css || processedOptions.html);
         if (!isBuild && hasFilesToSave) {
-            const promises: Promise<void>[] = [];
-            if (processedOptions.css) {
-                promises.push(ensureDirExistsAndWriteFile(inline(generatedFonts.generateCss()), processedOptions.cssDest));
-            }
-            if (processedOptions.html) {
-                promises.push(ensureDirExistsAndWriteFile(generatedFonts.generateHtml(), processedOptions.htmlDest));
-            }
-            await Promise.all(promises);
+            await Promise.all([
+                processedOptions.css && ensureDirExistsAndWriteFile(inline(generatedFonts.generateCss()), processedOptions.cssDest),
+                processedOptions.html && ensureDirExistsAndWriteFile(generatedFonts.generateHtml(), processedOptions.htmlDest),
+            ]);
         }
         if (updateFiles) {
             const module = _moduleGraph?.getModuleById(resolvedVirtualModuleId);

src/optionParser.ts

@@ -145,6 +145,12 @@ export interface IconPluginOptions<T extends GeneratedFontTypes = GeneratedFontT
      * @default false
      */
     inline?: boolean;
+    /**
+     * Allow outputting assets (HTML, CSS, and Fonts) during build.
+     * @see {@link https://github.com/atlowChemi/vite-svg-2-webfont/issues/32#issuecomment-2203187501}
+     * @default false
+     */
+    allowWriteFilesInBuild?: boolean;
 }
 
 export function parseIconTypesOption<T extends GeneratedFontTypes = GeneratedFontTypes>({ types }: Pick<IconPluginOptions<T>, 'types'>): T[] {