@open-xchange/vite-plugin-ox-manifests 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [Unreleased]
+
+## [0.6.0] - 2023-05-16
+
+### Changed
+
+- Convert source code to TypeScript [`029a4c7`](https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/commit/029a4c75c96483a221a54fc54589467b1a77eead)
+
+### Removed
+
+- Coverage files from npm package [`11fc7a8`](https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/commit/11fc7a8ba825f1a3bf1913b0134b57b1d1029f99)
+
+
+## [0.5.4] - 2023-03-17
+
+### Removed
+
+- Test files from npm package [`9d76062`](https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/commit/9d760623362bcbbb7e52fd551a0693cc43c61ed5)
+
+
+## [0.5.3] - 2023-03-17
+
+### Added
+
+- Add @open-xchange/lint [`c5ac8b6`](https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/commit/c5ac8b6009c8c035a2c609a2368a7ccfd422e65a)
+
+
+## [0.5.2] - 2022-12-13
+
+- Start Changelog
+
+[unreleased]: https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/compare/0.6.0...main
+[0.6.0]: https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/compare/0.5.4...0.6.0
+[0.5.4]: https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/compare/0.5.3...0.5.4
+[0.5.3]: https://gitlab.open-xchange.com/frontend/vite-plugin-ox-manifests/compare/0.5.2...0.5.3

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import type { Plugin } from 'vite';
+import { mergeManifests } from './util';
+export { mergeManifests };
+export interface OxManifest {
+    namespace: string;
+    path: string;
+    requires?: string;
+    raw?: string;
+    generator?: string;
+}
+/**
+ * Configuration options for the Vite plugin "vite-plugin-ox-manifests".
+ */
+export interface VitePluginOxManifestsOptions {
+    /**
+     * If set to `true`, this plugin will watch manifest changes and reload the
+     * UI. Default value is `false`.
+     */
+    watch?: boolean;
+    /**
+     * Convenience method to specify additional entry points for the production
+     * build. Can be specified as a glob-pattern.
+     */
+    entryPoints?: string;
+    /**
+     * Specifies, that every path in a manifest is used as an entry-point for the
+     * production build. Default is `true`!
+     */
+    manifestsAsEntryPoints?: boolean;
+    /**
+     * If disabled, settings will not be automatically detected and therefore
+     * have to provide a manual manifest.json. Default is `true`!
+     */
+    autoloadSettings?: boolean;
+    /**
+     * An array of valid file-extensions for entry points. Default is
+     * `['js', 'mjs', 'ts']`.
+     */
+    supportedEntryExtensions?: string[];
+    /**
+     * An object that will be translated into a `meta.json` file in the root
+     * directory.
+     */
+    meta?: object | null;
+}
+/**
+ * Type shape of the Vite plugin "vite-plugin-ox-manifests".
+ */
+export interface VitePluginOxManifests extends Plugin {
+    getManifests(): Promise<OxManifest[]>;
+}
+export declare const PROJECT_NAME = "@open-xchange/vite-plugin-ox-manifests";
+/**
+ * Creates a vite-plugin to include manifests in dev and production mode
+ */
+export default function pluginOxManifests(options?: VitePluginOxManifestsOptions): VitePluginOxManifests;

package/dist/index.js

@@ -0,0 +1,175 @@
+import { deepMergeObject, mergeManifests } from './util';
+import manifestsPlugin from './plugins/manifests';
+import relativePathsPlugin from './plugins/relative-paths';
+import settingsPlugin from './plugins/settings';
+import servePlugin from './plugins/serve';
+import gettextPlugin from './plugins/gettext';
+import metaPlugin from './plugins/meta';
+export { mergeManifests };
+export const PROJECT_NAME = '@open-xchange/vite-plugin-ox-manifests';
+/**
+ * Creates a vite-plugin to include manifests in dev and production mode
+ */
+export default function pluginOxManifests(options) {
+    const resolvedOptions = {
+        watch: false,
+        entryPoints: '',
+        manifestsAsEntryPoints: true,
+        autoloadSettings: true,
+        supportedEntryExtensions: ['js', 'mjs', 'ts'],
+        meta: null,
+        ...options
+    };
+    let resolvedConfig;
+    const plugins = [
+        // add settings first
+        settingsPlugin(resolvedOptions),
+        relativePathsPlugin(resolvedOptions),
+        servePlugin(resolvedOptions),
+        gettextPlugin(resolvedOptions),
+        metaPlugin(resolvedOptions),
+        // manifest plugin last
+        manifestsPlugin(resolvedOptions)
+    ];
+    const pluginManifests = {
+        name: PROJECT_NAME,
+        enforce: 'post',
+        async config(config, env) {
+            for (const plugin of plugins) {
+                plugin.pluginResolved?.(pluginManifests);
+                if (typeof plugin.config === 'function') {
+                    config = (await plugin.config.call(this, config, env)) || config;
+                }
+                else if (plugin.config) {
+                    throw new TypeError(`object hooks not supported, specify function callback (${plugin.name}.config)`);
+                }
+            }
+            return config;
+        },
+        async getManifests() {
+            const manifests = [];
+            for (const plugin of plugins) {
+                if (plugin.getManifests) {
+                    const result = await plugin.getManifests.call(this);
+                    manifests.push(...result);
+                }
+            }
+            return mergeManifests(manifests);
+        },
+        async configResolved(config) {
+            resolvedConfig = config;
+            for (const plugin of plugins) {
+                if (typeof plugin.configResolved === 'function') {
+                    await plugin.configResolved.call(this, config);
+                }
+                else if (plugin.configResolved) {
+                    throw new TypeError(`object hooks not supported, specify function callback (${plugin.name}.configResolved)`);
+                }
+            }
+        },
+        async options(options) {
+            if (resolvedConfig.mode === 'production') {
+                options.preserveEntrySignatures = 'strict';
+            }
+            for (const plugin of plugins) {
+                if (typeof plugin.options === 'function') {
+                    options = (await plugin.options.call(this, options)) || options;
+                }
+                else if (plugin.options) {
+                    throw new TypeError(`${plugin.name}.options: object hooks not supported, specify function callback`);
+                }
+            }
+            return options;
+        },
+        async buildStart(options) {
+            for (const plugin of plugins) {
+                if (typeof plugin.buildStart === 'function') {
+                    await plugin.buildStart.call(this, options);
+                }
+                else if (plugin.buildStart) {
+                    throw new TypeError(`${plugin.name}.buildStart: object hooks not supported, specify function callback`);
+                }
+            }
+        },
+        async configureServer(server) {
+            for (const plugin of plugins) {
+                if (typeof plugin.configureServer === 'function') {
+                    await plugin.configureServer.call(this, server);
+                }
+                else if (plugin.configureServer) {
+                    throw new TypeError(`${plugin.name}.configureServer: object hooks not supported, specify function callback`);
+                }
+            }
+        },
+        async resolveId(source, importer, options) {
+            for (const plugin of plugins) {
+                if (typeof plugin.resolveId === 'function') {
+                    const result = await plugin.resolveId.call(this, source, importer, options);
+                    if (result !== undefined)
+                        return result;
+                }
+                else if (plugin.resolveId) {
+                    throw new TypeError(`${plugin.name}.resolveId: object hooks not supported, specify function callback`);
+                }
+            }
+            return undefined;
+        },
+        async load(id) {
+            for (const plugin of plugins) {
+                if (typeof plugin.load === 'function') {
+                    const result = await plugin.load.call(this, id);
+                    if (result !== undefined)
+                        return result;
+                }
+                else if (plugin.load) {
+                    throw new TypeError(`${plugin.name}.load: object hooks not supported, specify function callback`);
+                }
+            }
+            return undefined;
+        },
+        async transform(code, id) {
+            let result = {};
+            for (const plugin of plugins) {
+                if (typeof plugin.transform === 'function') {
+                    // TODO check what happens if there is already meta from other plugins
+                    const that = await plugin.transform.call(this, code, id);
+                    if (that && typeof that === 'object') {
+                        result = deepMergeObject(result, that);
+                    }
+                }
+                else if (plugin.transform) {
+                    throw new TypeError(`${plugin.name}.transform: object hooks not supported, specify function callback`);
+                }
+            }
+            return Object.keys(result).length ? result : undefined;
+        },
+        async generateBundle(options, bundle, isWrite) {
+            for (const plugin of plugins) {
+                if (typeof plugin.generateBundle === 'function') {
+                    await plugin.generateBundle.call(this, options, bundle, isWrite);
+                }
+                else if (plugin.generateBundle) {
+                    throw new TypeError(`${plugin.name}.generateBundle: object hooks not supported, specify function callback`);
+                }
+            }
+        },
+        async transformIndexHtml(src, ctx) {
+            for (const plugin of plugins) {
+                if (typeof plugin.transformIndexHtml === 'function') {
+                    const result = await plugin.transformIndexHtml.call(this, src, ctx);
+                    if (typeof result === 'string') {
+                        src = result;
+                    }
+                    else if (result) {
+                        throw new TypeError(`${plugin.name}.transformIndexHtml: tag descriptors not supported, return simple string`);
+                    }
+                }
+                else if (plugin.transformIndexHtml) {
+                    throw new TypeError(`${plugin.name}.transformIndexHtml: object hooks not supported, specify function callback`);
+                }
+            }
+            return src;
+        }
+    };
+    return pluginManifests;
+}

package/dist/plugins/gettext.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./plugin").VitePluginOxManifestsPluginFn;
+export default _default;

package/dist/plugins/gettext.js

@@ -0,0 +1,63 @@
+import { dirname, posix } from 'node:path';
+import { readdir } from 'node:fs/promises';
+import { normalizePath } from 'vite';
+import { PROJECT_NAME as GETTEXT_PROJECT_NAME, parsePoFile, namespacesFrom } from '@open-xchange/rollup-plugin-po2json';
+import { definePlugin } from './plugin';
+import { applyInputToOptions } from '../util';
+import { PROJECT_NAME } from '../index';
+export default definePlugin(() => {
+    const manifests = [];
+    let resolvedConfig;
+    return {
+        name: `${PROJECT_NAME}/gettext-plugin`,
+        configResolved(config) {
+            resolvedConfig = config;
+        },
+        async options(options) {
+            const gettextPlugin = resolvedConfig.plugins.find(plugin => plugin.name === GETTEXT_PROJECT_NAME);
+            if (!gettextPlugin)
+                return;
+            const { meta: { poFiles, defaultDictionary, defaultLanguage } } = gettextPlugin;
+            const input = {};
+            // add dictionaries as entry points
+            const poDir = dirname(poFiles);
+            const files = (await readdir(poDir)).filter(f => f.indexOf(defaultLanguage) >= 0).map(f => normalizePath(`${poDir}/${f}`));
+            await Promise.all(files.map(async (file) => {
+                const po = await parsePoFile(file);
+                for (const namespace of namespacesFrom(po.items)) {
+                    if (namespace !== defaultDictionary) {
+                        input[namespace] = `gettext?dictionary=${namespace}`;
+                        manifests.push({ namespace: 'i18n', path: namespace });
+                    }
+                }
+            }));
+            input[defaultDictionary] = 'gettext';
+            manifests.push({ namespace: 'i18n', path: defaultDictionary });
+            if (resolvedConfig.mode === 'production') {
+                applyInputToOptions(input, options);
+            }
+            return options;
+        },
+        getManifests() {
+            if (resolvedConfig.mode === 'production')
+                return manifests;
+            return manifests.map(manifest => ({ ...manifest, raw: posix.join(resolvedConfig.base, `/@id/${manifest.path}.js`) }));
+        },
+        generateBundle(_options, bundle) {
+            for (const file in bundle) {
+                const chunk = bundle[file];
+                if (chunk.type !== 'chunk' || !chunk.facadeModuleId)
+                    continue;
+                const modules = Object.keys(chunk.modules);
+                if (modules.length === 0)
+                    modules.push(chunk.facadeModuleId);
+                for (const id of modules) {
+                    const meta = this.getModuleInfo(id)?.meta;
+                    if (meta.gettext?.dictionary === true) {
+                        (meta.manifests ??= []).push({ namespace: 'i18n', path: '' });
+                    }
+                }
+            }
+        }
+    };
+});

package/dist/plugins/manifests.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./plugin").VitePluginOxManifestsPluginFn;
+export default _default;

package/dist/plugins/manifests.js

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import fastGlob from 'fast-glob';
+import { definePlugin } from './plugin';
+import { applyInputToOptions, basepath, joinUrlPaths, stringifyJSON } from '../util';
+import { PROJECT_NAME } from '../index';
+async function getManifestEntryFile(basePath, extensions) {
+    if (path.extname(basePath)) {
+        try {
+            await fs.promises.stat(basePath);
+            return path.parse(basePath);
+        }
+        catch (e) {
+            throw new Error(`Cannot find file "${basePath}"`);
+        }
+    }
+    for (const ext of extensions) {
+        try {
+            await fs.promises.stat(`${basePath}.${ext}`);
+            return path.parse(`${basePath}.${ext}`);
+        }
+        catch { }
+    }
+    throw new Error(`Cannot find file "${basePath}"`);
+}
+export default definePlugin(({ supportedEntryExtensions, entryPoints, manifestsAsEntryPoints }) => {
+    const manifestModules = new Map();
+    let resolvedConfig;
+    let inputOptions;
+    let viteManifestPlugin;
+    async function buildViteManifests(options, bundle) {
+        return new Promise((resolve, reject) => {
+            // local async context to satisfy type checker expecting void callback for promise constructor
+            (async function () {
+                if (typeof viteManifestPlugin.buildStart !== 'function' || typeof viteManifestPlugin.generateBundle !== 'function') {
+                    throw new Error(`${PROJECT_NAME}: missing required callbacks in plugin 'vite:manifest'`);
+                }
+                // fake `PluginContext` to be passed to Vite's manifest plugin, needed to extract the asset data
+                const context = {
+                    emitFile(file) {
+                        if (file.type === 'asset' && typeof file.source === 'string') {
+                            resolve(JSON.parse(file.source));
+                        }
+                        else {
+                            reject(new Error(`${PROJECT_NAME}: received unexpected manifest data from plugin 'vite:manifest'`));
+                        }
+                    },
+                    getFileName: () => 'Not implemented'
+                };
+                // manually invoke plugin hooks (in a local async context to satisfy type checker expecting sync promise callbacks)
+                await viteManifestPlugin.buildStart.call(context, inputOptions);
+                await viteManifestPlugin.generateBundle.call(context, options, bundle, false);
+            })().catch(reject);
+        });
+    }
+    return {
+        name: `${PROJECT_NAME}/manifests-plugin`,
+        config(config) {
+            (config.build ??= {}).manifest = true;
+        },
+        configResolved(config) {
+            resolvedConfig = config;
+            if (resolvedConfig.mode !== 'production')
+                return;
+            // extract the vite:manifest plugin from the list
+            const index = config.plugins.findIndex(plugin => plugin.name === 'vite:manifest');
+            viteManifestPlugin = config.plugins.splice(index, 1)[0];
+        },
+        async options(options) {
+            const input = {};
+            if (entryPoints) {
+                const entryPointFiles = await fastGlob(entryPoints, { absolute: true });
+                for (const entry of entryPointFiles) {
+                    const baseLength = resolvedConfig.root.length + 1;
+                    const extLength = path.extname(entry).length;
+                    input[entry.substring(baseLength, entry.length - extLength)] = entry;
+                }
+            }
+            // 1. load all json files
+            const root = resolvedConfig.root;
+            const entries = await fastGlob(`${root.replace(/\\/g, '/')}/**/manifest.json`);
+            // 2. find every file that is referenced by that json file
+            for (const entry of entries) {
+                const rawData = await fs.promises.readFile(entry, 'utf-8');
+                const json = JSON.parse(rawData);
+                const manifests = Array.isArray(json) ? json : [json];
+                const manifestDir = path.dirname(entry).substring(root.length + 1);
+                await Promise.all(manifests.map(async ({ path: srcManifestEntryPath = joinUrlPaths(manifestDir, 'register'), ...rest }) => {
+                    const { dir, base } = await getManifestEntryFile(joinUrlPaths(root, srcManifestEntryPath), supportedEntryExtensions);
+                    const manifestEntryPath = joinUrlPaths(dir, base);
+                    if (manifestsAsEntryPoints) {
+                        input[basepath(joinUrlPaths(path.dirname(srcManifestEntryPath), base))] = manifestEntryPath;
+                    }
+                    // 3. put the file content except path into the manifest modules
+                    const modules = manifestModules.get(manifestEntryPath);
+                    manifestModules.set(manifestEntryPath, (modules || []).concat({ path: '', ...rest }));
+                }));
+            }
+            if (resolvedConfig.mode === 'production') {
+                applyInputToOptions(input, options);
+            }
+            return options;
+        },
+        buildStart(options) {
+            inputOptions = options;
+        },
+        // specific call to collect all manifests
+        getManifests() {
+            return Array.from(manifestModules, ([path, manifests]) => manifests.map(m => ({ ...m, path: basepath(path.slice(resolvedConfig.root.length + 1)) }))).flat(1);
+        },
+        transform(_code, id) {
+            if (resolvedConfig.mode !== 'production')
+                return;
+            const manifests = manifestModules.get(id);
+            return manifests ? { meta: { manifests } } : undefined;
+        },
+        async generateBundle(options, bundle) {
+            const viteManifests = await buildViteManifests(options, bundle);
+            for (const entry in viteManifests) {
+                const chunk = bundle[viteManifests[entry].file];
+                if (chunk.type === 'chunk' && chunk.facadeModuleId) {
+                    viteManifests[entry].meta = this.getModuleInfo(chunk.facadeModuleId)?.meta;
+                }
+            }
+            this.emitFile({
+                fileName: 'manifest.json',
+                type: 'asset',
+                source: stringifyJSON(resolvedConfig, viteManifests)
+            });
+        }
+    };
+});

package/dist/plugins/meta.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./plugin").VitePluginOxManifestsPluginFn;
+export default _default;

package/dist/plugins/meta.js

@@ -0,0 +1,21 @@
+import { definePlugin } from './plugin';
+import { stringifyJSON } from '../util';
+import { PROJECT_NAME } from '../index';
+export default definePlugin(({ meta }) => {
+    let resolvedConfig;
+    return {
+        name: `${PROJECT_NAME}/meta-plugin`,
+        configResolved(config) {
+            resolvedConfig = config;
+        },
+        generateBundle() {
+            if (meta && Object.keys(meta).length) {
+                this.emitFile({
+                    fileName: 'meta.json',
+                    type: 'asset',
+                    source: stringifyJSON(resolvedConfig, meta)
+                });
+            }
+        }
+    };
+});

package/dist/plugins/plugin.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin } from 'vite';
+import type { GettextPluginModuleMeta } from '@open-xchange/rollup-plugin-po2json';
+import type { OxManifest, VitePluginOxManifests, VitePluginOxManifestsOptions } from '../index';
+/**
+ * Type shape of an internal manifests implementation plugin.
+ */
+export interface VitePluginOxManifestsPlugin extends Plugin {
+    pluginResolved?(plugin: VitePluginOxManifests): void;
+    getManifests?(): OxManifest[] | Promise<OxManifest[]>;
+}
+/**
+ * Type shape of internal module metadata used by the manifests plugin.
+ */
+export interface VitePluginOxManifestsModuleMeta extends GettextPluginModuleMeta {
+    manifests?: OxManifest[];
+}
+/**
+ * Plugin generator function.
+ */
+export type VitePluginOxManifestsPluginFn = (options: Required<VitePluginOxManifestsOptions>) => VitePluginOxManifestsPlugin;
+/**
+ * Helper for type safety. Inspired by Vite's `defineConfig`.
+ */
+export declare function definePlugin(fn: VitePluginOxManifestsPluginFn): VitePluginOxManifestsPluginFn;

package/dist/plugins/plugin.js

@@ -0,0 +1,6 @@
+/**
+ * Helper for type safety. Inspired by Vite's `defineConfig`.
+ */
+export function definePlugin(fn) {
+    return fn;
+}

package/dist/plugins/relative-paths.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./plugin").VitePluginOxManifestsPluginFn;
+export default _default;

package/dist/plugins/relative-paths.js

@@ -0,0 +1,9 @@
+import { definePlugin } from './plugin';
+import { PROJECT_NAME } from '../index';
+export default definePlugin(options => {
+    if ('transformAbsolutePaths' in options)
+        console.warn("transformAbsolutePaths is no longer used. Use `base: './'` with vite 3");
+    return {
+        name: `${PROJECT_NAME}/relative-paths-plugin`
+    };
+});

package/dist/plugins/serve.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./plugin").VitePluginOxManifestsPluginFn;
+export default _default;

package/dist/plugins/serve.js

@@ -0,0 +1,66 @@
+import path, { posix } from 'node:path';
+import parseurl from 'parseurl';
+import chokidar from 'chokidar';
+import { definePlugin } from './plugin';
+import { PROJECT_NAME } from '../index';
+function sendJSON(res, data) {
+    res.statusCode = 200;
+    res.setHeader('Content-Type', 'application/json');
+    res.write(JSON.stringify(data));
+    return res.end();
+}
+export default definePlugin(({ watch }) => {
+    let resolvedConfig;
+    let resolvedPlugin;
+    let manifestRegex;
+    let depsRegex;
+    return {
+        name: `${PROJECT_NAME}/serve-plugin`,
+        pluginResolved(plugin) {
+            resolvedPlugin = plugin;
+        },
+        configResolved(config) {
+            resolvedConfig = config;
+            manifestRegex = new RegExp(`^${config.base}(api/manifest.json|manifests)$`);
+            depsRegex = new RegExp(`^${config.base}(api/deps.json|dependencies)$`);
+        },
+        configureServer({ ws, middlewares, moduleGraph }) {
+            function addTimestamp(manifests) {
+                for (const manifest of manifests) {
+                    // TODO what about other file types?
+                    const id = `${resolvedConfig.root}/${manifest.path}.js`;
+                    const moduleNode = moduleGraph.idToModuleMap.get(id);
+                    const hmrTS = moduleNode?.lastHMRTimestamp;
+                    if (hmrTS)
+                        manifest.raw = posix.join(resolvedConfig.base, `/${manifest.path}.js?t=${hmrTS}`);
+                }
+            }
+            middlewares.use((req, res, next) => {
+                if (req.method !== 'GET')
+                    return next();
+                const url = parseurl(req);
+                if (!url?.path)
+                    return next();
+                if (manifestRegex.test(url.path)) {
+                    resolvedPlugin.getManifests().then(manifests => {
+                        addTimestamp(manifests);
+                        sendJSON(res, manifests);
+                    }, next);
+                    return;
+                }
+                if (depsRegex.test(url.path)) {
+                    return sendJSON(res, {});
+                }
+                next();
+            });
+            if (watch) {
+                const watcher = chokidar.watch(path.join(resolvedConfig.root, '**/manifest.json'))
+                    .on('ready', () => {
+                    watcher.on('all', path => {
+                        ws.send({ type: 'full-reload', path });
+                    });
+                });
+            }
+        }
+    };
+});

package/dist/plugins/settings.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./plugin").VitePluginOxManifestsPluginFn;
+export default _default;