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

package/dist/plugins/settings.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs/promises';
+import path, { posix } from 'node:path';
+import fastGlob from 'fast-glob';
+import { PROJECT_NAME as EXTERNALS_PROJECT_NAME } from '@open-xchange/vite-plugin-ox-externals';
+import { definePlugin } from './plugin';
+import { applyInputToOptions, basepath } from '../util';
+import { PROJECT_NAME } from '../index';
+function shiftSet(set) {
+    const result = set.values().next();
+    if (result.done)
+        return;
+    set.delete(result.value);
+    return result.value;
+}
+function assignSet(set, values) {
+    for (const value of values)
+        set.add(value);
+}
+function getRequirements(context, entry) {
+    let moduleInfo = context.getModuleInfo(entry);
+    if (!moduleInfo)
+        return [];
+    const open = new Set([...moduleInfo.importers, ...moduleInfo.dynamicImporters]);
+    const closed = new Set(open);
+    const entryPoints = [];
+    for (;;) {
+        const first = shiftSet(open);
+        if (first === undefined)
+            break;
+        if (first.includes('node_modules'))
+            continue;
+        moduleInfo = context.getModuleInfo(first);
+        if (!moduleInfo)
+            continue;
+        if (moduleInfo.isEntry) {
+            const { manifests } = moduleInfo.meta;
+            if (manifests) {
+                entryPoints.push(...manifests.map(manifest => ({ requires: 'true', ...manifest })));
+                continue;
+            }
+        }
+        const nextOpen = [...moduleInfo.importers, ...moduleInfo.dynamicImporters].filter(o => !closed.has(o));
+        assignSet(closed, nextOpen);
+        assignSet(open, nextOpen);
+    }
+    return [...new Set(entryPoints.map(e => e.requires).filter(Boolean))];
+}
+function mergeRequirements(requirements) {
+    if (requirements.length === 0)
+        return;
+    if (requirements.includes('true'))
+        return;
+    // check if is just a simple string
+    return requirements.map(req => /^[-\w]*$/.test(req) ? req : `(${req})`).join('||');
+}
+export default definePlugin(({ autoloadSettings }) => {
+    const settingsModules = new Map();
+    let resolvedConfig;
+    let externalPrefix;
+    let moduleGraph;
+    async function isSettingsFile(entry) {
+        const containsSettingsRegex = new RegExp(`import.+[,\\s]Settings.+from ['"][@${externalPrefix}]\\/io.ox\\/core\\/settings(\\.js)?['"]`);
+        const containsExportRegex = /export const settings = new Settings\(/;
+        const content = await fs.readFile(entry, { encoding: 'utf-8' });
+        // special case
+        if (entry === `${resolvedConfig.root}/io.ox/core/settings.js`)
+            return true;
+        return containsSettingsRegex.test(content) && containsExportRegex.test(content);
+    }
+    return {
+        name: `${PROJECT_NAME}/settings-plugin`,
+        configResolved(config) {
+            resolvedConfig = config;
+            const externalPlugin = resolvedConfig.plugins.find(plugin => plugin.name === EXTERNALS_PROJECT_NAME);
+            externalPrefix = externalPlugin ? externalPlugin.meta.prefix : '';
+        },
+        async options(options) {
+            if (!autoloadSettings)
+                return;
+            const input = {};
+            const root = resolvedConfig.root;
+            const entries = await fastGlob(`${root.replace(/\\/g, '/')}/**/*.{js,ts,mjs}`, { absolute: true });
+            await Promise.all(entries.map(async (entry) => {
+                if (!await isSettingsFile(entry))
+                    return;
+                settingsModules.set(entry, { namespace: 'settings', path: '', generator: 'settings' });
+                const baseLength = root.length + 1;
+                const extLength = path.extname(entry).length;
+                const entryPath = entry.substring(baseLength, entry.length - extLength);
+                input[entryPath] = entry;
+            }));
+            if (resolvedConfig.mode === 'production') {
+                applyInputToOptions(input, options);
+            }
+            return options;
+        },
+        configureServer(server) {
+            moduleGraph = server.moduleGraph;
+        },
+        // specific call to collect all manifests
+        getManifests() {
+            return Array.from(settingsModules, ([path, manifest]) => {
+                manifest.path = basepath(path.slice(resolvedConfig.root.length + 1));
+                const moduleNode = moduleGraph?.idToModuleMap.get(path);
+                if (moduleNode?.lastHMRTimestamp) {
+                    manifest.raw = posix.join(resolvedConfig.base, `/${manifest.path}.js?t=${moduleNode.lastHMRTimestamp}`);
+                }
+                return manifest;
+            });
+        },
+        transform(_code, id) {
+            if (resolvedConfig.mode !== 'production')
+                return;
+            const manifest = settingsModules.get(id);
+            return manifest ? { meta: { manifests: [manifest] } } : undefined;
+        },
+        generateBundle(_options, bundle) {
+            if (!autoloadSettings)
+                return;
+            for (const file in bundle) {
+                const chunk = bundle[file];
+                if (chunk.type !== 'chunk' || !chunk.facadeModuleId)
+                    continue;
+                const meta = this.getModuleInfo(chunk.facadeModuleId)?.meta;
+                if (!meta?.manifests)
+                    continue;
+                for (const manifest of meta.manifests) {
+                    if (manifest.generator !== 'settings')
+                        continue;
+                    delete manifest.generator;
+                    const requirements = getRequirements(this, chunk.facadeModuleId);
+                    if (!requirements.length)
+                        continue;
+                    const requires = mergeRequirements(requirements);
+                    if (requires)
+                        manifest.requires = requires;
+                }
+            }
+        }
+    };
+});

package/dist/util.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedConfig, ViteDevServer, Rollup } from 'vite';
+import type { OxManifest } from './index';
+export type Dict<T = unknown> = Record<string, T>;
+export declare function applyInputToOptions(input: Dict<string>, options: Rollup.InputOptions): void;
+export declare function joinUrlPaths(...paths: string[]): string;
+export declare function basepath(src: string): string;
+export declare function deepMergeObject(a: Dict, b: Dict): Dict;
+export declare function mergeManifests(manifests: OxManifest[]): OxManifest[];
+export declare function stringifyJSON({ build }: ResolvedConfig, json: unknown): string;
+export declare function waitForReload(server: ViteDevServer): Promise<void>;
+export declare function wait(millis: number): Promise<void>;

package/dist/util.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { normalizePath } from 'vite';
+export function applyInputToOptions(input, options) {
+    // apply changes to input
+    if (Object.keys(input).length > 0) {
+        if (options.input) {
+            if (typeof options.input === 'string') {
+                input.index = options.input;
+                options.input = input;
+            }
+            else if (Array.isArray(options.input)) {
+                options.input = [...options.input, ...Object.values(input)];
+            }
+            else {
+                Object.assign(input, options.input);
+                options.input = input;
+            }
+        }
+    }
+}
+export function joinUrlPaths(...paths) {
+    return normalizePath(path.join(...paths));
+}
+export function basepath(src) {
+    const { dir, name } = path.parse(src);
+    return joinUrlPaths(dir, name);
+}
+export function deepMergeObject(a, b) {
+    const keys = [...new Set([...Object.keys(a), ...Object.keys(b)])];
+    const result = {};
+    for (const key of keys) {
+        if (a[key] === undefined)
+            result[key] = b[key];
+        else if (b[key] === undefined)
+            result[key] = a[key];
+        else if (Array.isArray(a[key]) !== Array.isArray(b[key]))
+            throw new Error('Cannot merge different types');
+        else if (typeof a[key] !== typeof b[key])
+            throw new Error('Cannot merge different types');
+        else if (Array.isArray(a[key]))
+            result[key] = [...a[key], ...b[key]];
+        else if (typeof a[key] === 'object')
+            result[key] = deepMergeObject(a[key], b[key]);
+        else
+            result[key] = b[key];
+    }
+    return result;
+}
+export function mergeManifests(manifests) {
+    const manifestsByHash = new Map();
+    for (const manifest of manifests) {
+        const hash = `${manifest.namespace}--${manifest.path}`;
+        // overwrites existing ones. last wins
+        manifestsByHash.set(hash, manifest);
+    }
+    return Array.from(manifestsByHash.values());
+}
+export function stringifyJSON({ build }, json) {
+    return (build.minify === false) ? JSON.stringify(json, null, 2) : JSON.stringify(json);
+}
+export function waitForReload(server) {
+    return new Promise(resolve => {
+        const send = server.ws.send.bind(server.ws);
+        server.ws.send = function (arg1, ...args) {
+            try {
+                send(arg1, ...args);
+            }
+            finally {
+                if (typeof arg1 === 'object' && arg1.type === 'full-reload')
+                    resolve();
+            }
+        };
+    });
+}
+export async function wait(millis) {
+    await new Promise(resolve => setTimeout(resolve, millis));
+}

package/package.json

@@ -1,42 +1,44 @@
 {
   "name": "@open-xchange/vite-plugin-ox-manifests",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "A vite plugin to concat and serve ox manifests",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "type": "module",
   "repository": "git@gitlab.open-xchange.com:frontend/vite-plugin-ox-manifests.git",
   "author": "Richard Petersen",
   "license": "MIT",
   "scripts": {
-    "lint": "eslint *.js src/**/*.js test/**/**.js",
     "prepare": "husky install",
-    "test": "NODE_OPTIONS=\"--experimental-vm-modules --max_old_space_size=1792\" jest test/**/*.test.js --testTimeout=15000 --runInBand"
+    "lint": "tsc --noEmit && eslint . --ext .js,.cjs,.mjs,.ts",
+    "build": "npx --yes rimraf dist && tsc",
+    "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules --max_old_space_size=1792\" jest --testTimeout=15000 --runInBand"
   },
   "dependencies": {
-    "@open-xchange/rollup-plugin-po2json": "^0.5.0",
+    "@open-xchange/rollup-plugin-po2json": "^0.8.0",
     "chokidar": "^3.5.1",
-    "fast-glob": "^3.2.5",
-    "magic-string": "^0.26.2",
+    "fast-glob": "^3.2.12",
+    "magic-string": "^0.30.0",
     "parseurl": "^1.3.3"
   },
   "devDependencies": {
-    "@open-xchange/vite-plugin-ox-externals": "^0.3.0",
-    "@rollup/plugin-json": "^4.1.0",
-    "eslint": "^8.21.0",
-    "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jest": "^26.8.0",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.0.0",
-    "express": "^4.18.1",
-    "husky": "^8.0.1",
-    "jest": "^28.1.3",
+    "@open-xchange/lint": "^0.0.2",
+    "@open-xchange/vite-plugin-ox-externals": "^0.5.0",
+    "@types/node": "^20.1.5",
+    "@types/parseurl": "^1.3.1",
+    "@typescript-eslint/eslint-plugin": "^5.59.0",
+    "@typescript-eslint/parser": "^5.59.0",
+    "cross-env": "^7.0.3",
+    "eslint-plugin-jest": "^27.2.1",
+    "express": "^4.18.2",
+    "jest": "^29.5.0",
+    "jest-junit": "^16.0.0",
     "less": "^4.1.3",
-    "rollup": "^2.77.2",
-    "rollup-plugin-auto-external": "^2.0.0",
-    "vite": "^4.0.2"
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.4",
+    "vite": "^4.2.1"
   },
   "lint-staged": {
-    "*.js": "eslint --cache --fix"
+    "*.{js,cjs,mjs,ts}": "eslint --cache --fix"
   }
 }

package/.eslintrc.cjs

@@ -1,10 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    node: true,
-    es2021: true
-  },
-  extends: [
-    'standard'
-  ]
-}

package/.gitlab-ci.yml

@@ -1,26 +0,0 @@
-image: node:18-alpine
-
-stages:
-  - test
-
-unit tests:
-  stage: test
-  variables:
-    KUBERNETES_CPU_REQUEST: 2
-    KUBERNETES_CPU_LIMIT: 3
-    KUBERNETES_MEMORY_REQUEST: 2Gi
-    KUBERNETES_MEMORY_LIMIT: 2Gi
-  script:
-    - apk add git
-    - yarn
-    - yarn test --ci --coverage
-  coverage: /^Lines\s*:\s\d+.\d+\%/
-  artifacts:
-    reports:
-      junit: output/junit.xml
-      coverage_report:
-        coverage_format: cobertura
-        path: output/coverage/cobertura-coverage.xml
-  needs: []
-  tags:
-    - kubernetes

package/index.js

@@ -1,172 +0,0 @@
-import { PROJECT_NAME as name } from './src/constants.js'
-import manifestsPlugin from './src/plugins/manifests.js'
-import relativePathsPlugin from './src/plugins/relative-paths.js'
-import settingsPlugin from './src/plugins/settings.js'
-import servePlugin from './src/plugins/serve.js'
-import gettextPlugin from './src/plugins/gettext.js'
-import metaPlugin from './src/plugins/meta.js'
-import { deepMergeObject } from './src/util.js'
-
-/**
- * Creates a vite-plugin to include manifests in dev and production mode
- *
- * @param {object} [options]
- * @param {boolean} [options.watch=false] - If set to true, this plugin will watch manifest changes and reload the ui
- * @param {string} [options.entryPoints] - Convenience method to specify additional entry points for the production build. Can be specified as a glob-pattern.
- * @param {boolean} [options.manifestsAsEntryPoints=true] - Specifies, that every path in a manifest is used as an entry-point for the production build.
- * @param {boolean} [options.autoloadSettings=true] - If disabled, settings will not be automatically detected and therefore have to provide a manual manifest.json.
- * @param supportedEntryExtensions {string[]=['js', 'mjs', 'ts']} - An array of valid file-extensions for entry points.
- * @param {object} [options.meta] - An object that will be translated into a meta.json file in the root directory.
- */
-export default function ({
-  watch = false,
-  entryPoints,
-  manifestsAsEntryPoints = true,
-  transformAbsolutePaths,
-  autoloadSettings = true,
-  supportedEntryExtensions = ['js', 'mjs', 'ts'],
-  meta
-} = {}) {
-  const options = {
-    watch,
-    entryPoints,
-    manifestsAsEntryPoints,
-    transformAbsolutePaths,
-    autoloadSettings,
-    supportedEntryExtensions,
-    meta
-  }
-
-  const plugins = [
-    // add settings first
-    settingsPlugin(options),
-    relativePathsPlugin(options),
-    servePlugin(options),
-    gettextPlugin(options),
-    metaPlugin(options),
-    // manifest plugin last
-    manifestsPlugin(options)
-  ]
-  let resolvedConfig
-
-  const vitePluginOxManifests = {
-
-    name,
-
-    enforce: 'post',
-
-    async config (config, env) {
-      for (const plugin of plugins) {
-        if (plugin.config) {
-          config = (await plugin.config.call(this, config, env)) || config
-        }
-      }
-      return config
-    },
-
-    async getManifests () {
-      const manifestsByHash = {}
-      for (const plugin of plugins) {
-        if (plugin.getManifests) {
-          const manifests = await plugin.getManifests.call(this)
-          manifests.forEach(manifest => {
-            const hash = `${manifest.namespace}--${manifest.path}`
-            // overwrites existing ones. last wins
-            manifestsByHash[hash] = manifest
-          })
-        }
-      }
-      return Object.values(manifestsByHash)
-    },
-
-    async configResolved (config) {
-      resolvedConfig = config
-      for (const plugin of plugins) {
-        if (plugin.configResolved) {
-          plugin._config = config
-          await plugin.configResolved.call(this, config)
-        }
-      }
-    },
-
-    async options (options) {
-      if (resolvedConfig.mode === 'production') {
-        options.preserveEntrySignatures = 'strict'
-      }
-      for (const plugin of plugins) {
-        if (plugin.options) {
-          options = (await plugin.options.call(this, options)) || options
-        }
-      }
-      return options
-    },
-
-    buildStart (options) {
-      for (const plugin of plugins) {
-        if (plugin.buildStart) {
-          plugin.buildStart.call(this, options)
-        }
-      }
-    },
-
-    async configureServer (server) {
-      for (const plugin of plugins) {
-        if (plugin.configureServer) {
-          await plugin.configureServer.call(vitePluginOxManifests, server)
-        }
-      }
-    },
-
-    async resolveId (source, importer, options) {
-      for (const plugin of plugins) {
-        if (plugin.resolveId) {
-          const result = await plugin.resolveId.call(this, source, importer, options)
-          if (result !== undefined) return result
-        }
-      }
-    },
-
-    async load (id) {
-      for (const plugin of plugins) {
-        if (plugin.load) {
-          const result = await plugin.load.call(this, id)
-          if (result !== undefined) return result
-        }
-      }
-    },
-
-    async transform (code, id) {
-      let result = {}
-      for (const plugin of plugins) {
-        if (plugin.transform) {
-          // TODO check what happens if there is already meta from other plugins
-          const that = await plugin.transform.call(this, code, id)
-          if (that !== undefined) {
-            result = deepMergeObject(result, that)
-          }
-        }
-      }
-      if (Object.keys(result).length === 0) return
-      return result
-    },
-
-    async generateBundle (options, bundle) {
-      for (const plugin of plugins) {
-        if (plugin.generateBundle) {
-          await plugin.generateBundle.call(this, options, bundle)
-        }
-      }
-    },
-
-    async transformIndexHtml (src) {
-      for (const plugin of plugins) {
-        if (plugin.transformIndexHtml) {
-          src = (await plugin.transformIndexHtml.call(this, src)) || src
-        }
-      }
-      return src
-    }
-  }
-
-  return vitePluginOxManifests
-}

package/src/constants.js

@@ -1 +0,0 @@
-export const PROJECT_NAME = '@open-xchange/vite-plugin-ox-manifests'

package/src/plugins/gettext.js

@@ -1,69 +0,0 @@
-import { applyInputToOptions } from '../util.js'
-import path, { posix } from 'path'
-import { readdir } from 'fs/promises'
-import { normalizePath } from 'vite'
-import { parsePoFile, namespacesFrom } from '@open-xchange/rollup-plugin-po2json/lib/po2json.js'
-
-export default function () {
-  const manifests = []
-  let resolvedConfig
-  return {
-    configResolved (config) {
-      resolvedConfig = config
-    },
-
-    async options (options) {
-      const gettextPlugin = resolvedConfig.plugins.find(plugin => plugin.name === 'gettext')
-      if (!gettextPlugin) return
-
-      const { meta: { poFiles, defaultDictionary, defaultLanguage } } = gettextPlugin
-      const input = {}
-
-      // add dictionaries as entrypoints
-      if (typeof poFiles === 'string') {
-        const poDir = path.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) continue
-            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.map(({ namespace, path }) => ({ namespace, raw: posix.join(resolvedConfig.base, `/@id/${path}.js`), path }))
-      }
-      return manifests
-    },
-
-    async generateBundle (options, bundle) {
-      for (const file in bundle) {
-        const chunk = bundle[file]
-        if (!chunk.facadeModuleId) continue
-
-        const modules = Object.keys(chunk.modules)
-        if (modules.length === 0) modules.push(chunk.facadeModuleId)
-        modules.forEach(id => {
-          const meta = this.getModuleInfo(id)?.meta
-          if (meta?.gettext?.dictionary !== true) return
-
-          meta.manifests = meta.manifests || []
-          meta.manifests.push({ namespace: 'i18n' })
-        })
-      }
-    }
-  }
-}