@ws-ui/vite-plugins 1.0.0

package/dist/esbuild-plugin-import-meta-url/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'esbuild';
+declare const importMetaUrlPlugin: Plugin;
+export default importMetaUrlPlugin;

package/dist/esbuild-plugin-import-meta-url/index.js

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { resolve } from 'import-meta-resolve';
+const importMetaUrlPlugin = {
+    name: 'import.meta.url',
+    setup({ onLoad }) {
+        // Help vite that bundles/move files in dev mode without touching `import.meta.url` which breaks asset urls
+        onLoad({ filter: /.*\.js/, namespace: 'file' }, async (args) => {
+            if (/node_modules(\/|\\)(mime-types|mime-db)/.test(args.path)) {
+                return;
+            }
+            const code = readFileSync(args.path, 'utf8');
+            const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/g;
+            let i = 0;
+            let newCode = '';
+            for (let match = assetImportMetaUrlRE.exec(code); match != null; match = assetImportMetaUrlRE.exec(code)) {
+                newCode += code.slice(i, match.index);
+                const path = match[1].slice(1, -1);
+                const resolved = resolve(path, pathToFileURL(args.path).toString());
+                newCode += `new URL(${JSON.stringify(fileURLToPath(resolved))}, import.meta.url)`;
+                i = assetImportMetaUrlRE.lastIndex;
+            }
+            newCode += code.slice(i);
+            return { contents: newCode };
+        });
+    },
+};
+export default importMetaUrlPlugin;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import importMetaUrlPlugin from './esbuild-plugin-import-meta-url';
+import monacoEditorPlugin from './vite-plugin-monaco-editor';
+export { importMetaUrlPlugin, monacoEditorPlugin };

package/dist/index.js

@@ -0,0 +1,3 @@
+import importMetaUrlPlugin from './esbuild-plugin-import-meta-url';
+import monacoEditorPlugin from './vite-plugin-monaco-editor';
+export { importMetaUrlPlugin, monacoEditorPlugin };

package/dist/vite-plugin-monaco-editor/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vite';
+import { IMonacoEditorOpts } from './types';
+export default function monacoEditorPlugin(options?: IMonacoEditorOpts): Plugin;

package/dist/vite-plugin-monaco-editor/index.js

@@ -0,0 +1,98 @@
+import esbuild from 'esbuild';
+import * as path from 'path';
+import * as fs from 'fs';
+import { languageWorksByLabel } from './languageWork';
+import { workerMiddleware, cacheDir, getFilename, getWorkPath, } from './workerMiddleware';
+import { getWorks, isCDN, resolveMonacoPath } from './utils';
+export default function monacoEditorPlugin(options = {}) {
+    const languageWorkers = options.languageWorkers ||
+        Object.keys(languageWorksByLabel);
+    const publicPath = options.publicPath || 'assets';
+    const globalAPI = options.globalAPI || false;
+    const customWorkers = options.customWorkers || [];
+    const forceBuildCDN = options.forceBuildCDN || false;
+    options = {
+        ...options,
+        languageWorkers,
+        publicPath,
+        globalAPI,
+        customWorkers,
+        forceBuildCDN,
+    };
+    let resolvedConfig;
+    return {
+        name: 'vite-plugin-monaco-editor',
+        configResolved(getResolvedConfig) {
+            resolvedConfig = getResolvedConfig;
+        },
+        configureServer(server) {
+            if (isCDN(publicPath)) {
+                return;
+            }
+            workerMiddleware(server.middlewares, resolvedConfig, options);
+        },
+        transformIndexHtml(_html) {
+            const works = getWorks(options);
+            const workerPaths = getWorkPath(works, options, resolvedConfig);
+            const globals = {
+                MonacoEnvironment: `(function (paths) {
+          return {
+            globalAPI: ${globalAPI},
+            getWorkerUrl : function (moduleId, label) {
+              var result =  paths[label];
+              if (/^((http:)|(https:)|(file:)|(\\/\\/))/.test(result)) {
+                var currentUrl = String(window.location);
+                var currentOrigin = currentUrl.substr(0, currentUrl.length - window.location.hash.length - window.location.search.length - window.location.pathname.length);
+                if (result.substring(0, currentOrigin.length) !== currentOrigin) {
+                  var js = '/*' + label + '*/importScripts("' + result + '");';
+                  var blob = new Blob([js], { type: 'application/javascript' });
+                  return URL.createObjectURL(blob);
+                }
+              }
+              return result;
+            }
+          };
+        })(${JSON.stringify(workerPaths, null, 2)})`,
+            };
+            const descriptor = [
+                {
+                    tag: 'script',
+                    children: Object.keys(globals)
+                        .map((key) => `self[${JSON.stringify(key)}] = ${globals[key]};`)
+                        .join('\n'),
+                    injectTo: 'head-prepend',
+                },
+            ];
+            return descriptor;
+        },
+        writeBundle() {
+            if (isCDN(publicPath) && !forceBuildCDN) {
+                return;
+            }
+            const works = getWorks(options);
+            const distPath = options.customDistPath
+                ? options.customDistPath(resolvedConfig.root, resolvedConfig.build.outDir, resolvedConfig.base)
+                : path.join(resolvedConfig.root, resolvedConfig.build.outDir, resolvedConfig.base, options.publicPath || '');
+            //  console.log("distPath", distPath)
+            // write publicPath
+            if (!fs.existsSync(distPath)) {
+                fs.mkdirSync(distPath, {
+                    recursive: true,
+                });
+            }
+            for (const work of works) {
+                const filename = getFilename(work);
+                if (!fs.existsSync(cacheDir + filename)) {
+                    esbuild.buildSync({
+                        entryPoints: [resolveMonacoPath(work.entry)],
+                        bundle: true,
+                        outfile: cacheDir + filename,
+                    });
+                }
+                const contentBuffer = fs.readFileSync(cacheDir + filename);
+                const workDistPath = path.resolve(distPath, filename);
+                fs.writeFileSync(workDistPath, contentBuffer);
+            }
+        },
+    };
+}

package/dist/vite-plugin-monaco-editor/languageWork.d.ts

@@ -0,0 +1,6 @@
+import { IWorkerDefinition } from './types';
+export declare const languageWorkAttr: IWorkerDefinition[];
+declare const languageWorksByLabel: {
+    [language: string]: IWorkerDefinition;
+};
+export { languageWorksByLabel };

package/dist/vite-plugin-monaco-editor/languageWork.js

@@ -0,0 +1,35 @@
+export const languageWorkAttr = [
+    {
+        label: 'editorWorkerService',
+        filename: 'editor.worker.bundle.js',
+        entry: 'monaco-editor/esm/vs/editor/editor.worker',
+    },
+    {
+        label: 'textMateWorker',
+        filename: 'textmate.worker.bundle.js',
+        entry: '@codingame/monaco-vscode-textmate-service-override/worker?worker',
+    },
+    {
+        label: 'css',
+        filename: 'css.worker.bundle.js',
+        entry: '@codingame/monaco-vscode-standalone-css-language-features/worker',
+    },
+    {
+        label: 'html',
+        filename: 'html.worker.bundle.js',
+        entry: '@codingame/monaco-vscode-standalone-html-language-features/worker',
+    },
+    {
+        label: 'json',
+        filename: 'json.worker.bundle.js',
+        entry: '@codingame/monaco-vscode-standalone-json-language-features/worker',
+    },
+    {
+        label: 'typescript',
+        filename: 'ts.worker.bundle.js',
+        entry: '@codingame/monaco-vscode-standalone-typescript-language-features/worker',
+    },
+];
+const languageWorksByLabel = {};
+languageWorkAttr.forEach((languageWork) => (languageWorksByLabel[languageWork.label] = languageWork));
+export { languageWorksByLabel };

package/dist/vite-plugin-monaco-editor/types.d.ts

@@ -0,0 +1,30 @@
+export interface IWorkerDefinition {
+    label: string;
+    filename?: string;
+    entry: string;
+}
+export type EditorLanguageWorks = 'css' | 'html' | 'json' | 'typescript' | 'editorWorkerService';
+export interface IMonacoEditorOpts {
+    /**
+     * include only a subset of the languageWorkers supported.
+     */
+    languageWorkers?: EditorLanguageWorks[];
+    customWorkers?: IWorkerDefinition[];
+    /**
+     * Override the public path from which files generated by this plugin will be served.
+     * This wins out over Webpack's dynamic runtime path and can be useful to avoid attempting to load workers cross-
+     * origin when using a CDN for other static resources.
+     * Use e.g. '/' if you want to load your resources from the current origin.
+     */
+    publicPath?: string;
+    customDistPath?: (root: string, buildOutDir: string, base: string) => string;
+    forceBuildCDN?: boolean;
+    /**
+     * Specify whether the editor API should be exposed through a global `monaco` object or not. This
+     * option is applicable to `0.22.0` and newer version of `monaco-editor`. Since `0.22.0`, the ESM
+     * version of the monaco editor does no longer define a global `monaco` object unless
+     * `global.MonacoEnvironment = { globalAPI: true }` is set ([change
+     * log](https://github.com/microsoft/monaco-editor/blob/main/CHANGELOG.md#0220-29012021)).
+     */
+    globalAPI?: boolean;
+}

package/dist/vite-plugin-monaco-editor/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vite-plugin-monaco-editor/utils.d.ts

@@ -0,0 +1,7 @@
+import { IMonacoEditorOpts, IWorkerDefinition } from './types';
+/**
+ * Return a resolved path for a given Monaco file.
+ */
+export declare function resolveMonacoPath(filePath: string): string;
+export declare function getWorks(options: IMonacoEditorOpts): IWorkerDefinition[];
+export declare function isCDN(publicPath: string): boolean;

package/dist/vite-plugin-monaco-editor/utils.js

@@ -0,0 +1,26 @@
+import * as path from 'path';
+import { languageWorksByLabel } from './languageWork';
+/**
+ * Return a resolved path for a given Monaco file.
+ */
+export function resolveMonacoPath(filePath) {
+    try {
+        return path.resolve(path.join(process.cwd(), 'node_modules', filePath));
+    }
+    catch (err) {
+        return path.resolve(filePath);
+    }
+}
+export function getWorks(options) {
+    let works = (options.languageWorkers || [])
+        .map((work) => languageWorksByLabel[work])
+        .filter(Boolean);
+    works.push(...(options.customWorkers || []));
+    return works;
+}
+export function isCDN(publicPath) {
+    if (/^((http:)|(https:)|(file:)|(\/\/))/.test(publicPath)) {
+        return true;
+    }
+    return false;
+}

package/dist/vite-plugin-monaco-editor/workerMiddleware.d.ts

@@ -0,0 +1,9 @@
+import { Connect, ResolvedConfig } from 'vite';
+import { IMonacoEditorOpts, IWorkerDefinition } from './types';
+export declare function getFilenameByEntry(entry: string): string;
+export declare function getFilename(work: IWorkerDefinition): string;
+export declare const cacheDir = "node_modules/.monaco/";
+export declare function getWorkPath(works: IWorkerDefinition[], options: IMonacoEditorOpts, config: ResolvedConfig): {
+    [key: string]: string;
+};
+export declare function workerMiddleware(middlewares: Connect.Server, config: ResolvedConfig, options: IMonacoEditorOpts): void;

package/dist/vite-plugin-monaco-editor/workerMiddleware.js

@@ -0,0 +1,63 @@
+import { getWorks, isCDN, resolveMonacoPath } from './utils';
+import esbuild from 'esbuild';
+import * as fs from 'fs';
+import * as path from 'path';
+export function getFilenameByEntry(entry) {
+    entry = path.basename(entry, 'js');
+    return entry + '.bundle.js';
+}
+export function getFilename(work) {
+    return work.filename || getFilenameByEntry(work.entry);
+}
+export const cacheDir = 'node_modules/.monaco/';
+export function getWorkPath(works, options, config) {
+    const workerPaths = {};
+    for (const work of works) {
+        const filename = getFilename(work);
+        if (options.publicPath && isCDN(options.publicPath)) {
+            workerPaths[work.label] =
+                options.publicPath + '/' + filename;
+        }
+        else {
+            workerPaths[work.label] =
+                config.base + options.publicPath + '/' + filename;
+        }
+    }
+    if (workerPaths['typescript']) {
+        // javascript shares the same worker
+        workerPaths['javascript'] = workerPaths['typescript'];
+    }
+    if (workerPaths['css']) {
+        // scss and less share the same worker
+        workerPaths['less'] = workerPaths['css'];
+        workerPaths['scss'] = workerPaths['css'];
+    }
+    if (workerPaths['html']) {
+        // handlebars, razor and html share the same worker
+        workerPaths['handlebars'] = workerPaths['html'];
+        workerPaths['razor'] = workerPaths['html'];
+    }
+    return workerPaths;
+}
+export function workerMiddleware(middlewares, config, options) {
+    const works = getWorks(options);
+    // clear cacheDir
+    if (fs.existsSync(cacheDir)) {
+        fs.rmdirSync(cacheDir, { recursive: true, force: true });
+    }
+    for (const work of works) {
+        const filename = getFilename(work);
+        middlewares.use(config.base + options.publicPath + '/' + filename, function (_req, res, _next) {
+            if (!fs.existsSync(cacheDir + filename)) {
+                esbuild.buildSync({
+                    entryPoints: [resolveMonacoPath(work.entry)],
+                    bundle: true,
+                    outfile: cacheDir + filename,
+                });
+            }
+            const contentBuffer = fs.readFileSync(cacheDir + filename);
+            res.setHeader('Content-Type', 'text/javascript');
+            res.end(contentBuffer);
+        });
+    }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@ws-ui/vite-plugins",
+  "private": false,
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.9",
+    "typescript": "^5.2.2",
+    "vite": "^4.5.3"
+  },
+  "dependencies": {
+    "import-meta-resolve": "^4.0.0"
+  }
+}