@meethive/vite 0.0.2 → 0.0.3

package/dist/dynamic-remote.d.ts

@@ -1,2 +1,85 @@
-export * from './src/runtime/dynamic-remote';
-//# sourceMappingURL=dynamic-remote.d.ts.map
+/**
+ * Dynamic remote component manager
+ */
+export declare class DynamicRemoteManager {
+    private remoteCache;
+    private loadingPromises;
+    /**
+     * Add a remote dynamically at runtime
+     * @param name Remote name
+     * @param config Remote configuration
+     */
+    addRemote(name: string, config: RemoteOptions): Promise<void>;
+    /**
+     * Load a remote component dynamically
+     * @param remoteName Remote name
+     * @param componentName Component name to load from remote
+     * @returns Promise of the loaded component
+     */
+    loadRemoteComponent(remoteName: string, componentName: string): Promise<any>;
+    private doLoadRemoteComponent;
+    /**
+     * Preload a remote component
+     * @param remoteName Remote name
+     * @param componentName Component name
+     */
+    preloadRemoteComponent(remoteName: string, componentName: string): Promise<void>;
+    /**
+     * Remove a remote component from cache
+     * @param remoteName Remote name
+     * @param componentName Component name
+     */
+    clearRemoteComponentCache(remoteName: string, componentName?: string): void;
+    /**
+     * Get all cached remote components
+     */
+    getCachedRemotes(): string[];
+    /**
+     * Check if a remote component is cached
+     * @param remoteName Remote name
+     * @param componentName Component name
+     */
+    isRemoteComponentCached(remoteName: string, componentName: string): boolean;
+}
+
+export declare const dynamicRemoteManager: DynamicRemoteManager;
+
+/**
+ * Convenience function to dynamically load remote component
+ * @param config Remote component configuration
+ */
+export declare function loadDynamicRemoteComponent(config: RemoteComponentConfig): Promise<any>;
+
+export declare interface RemoteComponentConfig {
+    name: string;
+    component: string;
+    url: string | (() => string | Promise<string>);
+    options?: RemoteOptions;
+}
+
+/**
+ * Dynamic remote loader for runtime
+ * Provides utilities to dynamically load and manage remote components at runtime
+ */
+export declare interface RemoteOptions {
+    url: string | (() => string | Promise<string>);
+    format?: 'esm' | 'systemjs' | 'var';
+    from?: 'vite' | 'webpack';
+    shareScope?: string;
+    external?: string | string[];
+    externalType?: 'url' | 'promise';
+}
+
+/**
+ * Vue 3 composable for dynamic remote loading
+ * @param remoteName Remote name
+ * @param componentName Component name
+ */
+export declare function useDynamicRemote(remoteName: string, componentName: string): {
+    component: any;
+    loading: any;
+    error: any;
+    reload: () => Promise<void>;
+};
+
+export { }

package/dist/index.d.ts

@@ -1,3 +1,51 @@
-export { default } from './src';
-export * from './src';
-//# sourceMappingURL=index.d.ts.map
+import { Plugin } from 'vite';
+import { VitePluginFederationOptions } from '../types';
+
+declare type EditorLanguageWorks = 'css' | 'html' | 'json' | 'typescript' | 'editorWorkerService';
+
+export declare function federation(options: VitePluginFederationOptions): Plugin;
+
+declare 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;
+}
+
+declare interface IWorkerDefinition {
+    label: string;
+    entry: string;
+}
+
+export declare function monacoEditorPlugin(options: IMonacoEditorOpts): Plugin;
+
+export declare function sharpOptimize(options?: SharpOptimizeOptions): Plugin;
+
+declare type SharpOptimizeOptions = {
+    include?: (string | RegExp)[];
+    exclude?: (string | RegExp)[];
+    jpegQuality?: number;
+    pngQuality?: number;
+    webpQuality?: number;
+    avifQuality?: number;
+};
+
+export { }

package/dist/index.js

@@ -1,5 +1,27 @@
 "use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const virtual = require("@rollup/plugin-virtual");
 const path = require("path");
 const estreeWalker = require("estree-walker");
@@ -7,14 +29,14 @@ const MagicString = require("magic-string");
 const path$1 = require("node:path");
 const fs = require("fs");
 require("crypto");
-const dynamicRemote = require("./dynamic-remote.js");
+require("./dynamic-remote.js");
+const esbuild = require("esbuild");
 const EXPOSES_MAP = /* @__PURE__ */ new Map();
 const EXPOSES_KEY_MAP = /* @__PURE__ */ new Map();
 const SHARED = "shared";
 const DYNAMIC_LOADING_CSS = "dynamicLoadingCss";
 const DYNAMIC_LOADING_CSS_PREFIX = "__v__css__";
 const DEFAULT_ENTRY_FILENAME = "remoteEntry.js";
-const VitePluginFederationVersion = "1.5.0";
 const builderInfo = {
   builder: "rollup",
   assetsDir: "",
@@ -1794,9 +1816,284 @@ function federation(options) {
     }
   };
 }
-exports.DynamicRemoteManager = dynamicRemote.DynamicRemoteManager;
-exports.dynamicRemoteManager = dynamicRemote.dynamicRemoteManager;
-exports.loadDynamicRemoteComponent = dynamicRemote.loadDynamicRemoteComponent;
-exports.useDynamicRemote = dynamicRemote.useDynamicRemote;
-exports.VitePluginFederationVersion = VitePluginFederationVersion;
-exports.default = federation;
+const languageWorkAttr = [
+  {
+    label: "editorWorkerService",
+    entry: "monaco-editor/esm/vs/editor/editor.worker"
+  },
+  {
+    label: "css",
+    entry: "monaco-editor/esm/vs/language/css/css.worker"
+  },
+  {
+    label: "html",
+    entry: "monaco-editor/esm/vs/language/html/html.worker"
+  },
+  {
+    label: "json",
+    entry: "monaco-editor/esm/vs/language/json/json.worker"
+  },
+  {
+    label: "typescript",
+    entry: "monaco-editor/esm/vs/language/typescript/ts.worker"
+  }
+];
+const languageWorksByLabel = {};
+languageWorkAttr.forEach(
+  (languageWork) => languageWorksByLabel[languageWork.label] = languageWork
+);
+function getFilenameByEntry(entry) {
+  entry = path.basename(entry, "js");
+  return entry + ".bundle.js";
+}
+const cacheDir = "node_modules/.monaco/";
+function getWorkPath(works, options, config) {
+  const workerPaths = {};
+  for (const work of works) {
+    if (isCDN(options.publicPath)) {
+      workerPaths[work.label] = options.publicPath + "/" + getFilenameByEntry(work.entry);
+    } else {
+      workerPaths[work.label] = config.base + options.publicPath + "/" + getFilenameByEntry(work.entry);
+    }
+  }
+  if (workerPaths["typescript"]) {
+    workerPaths["javascript"] = workerPaths["typescript"];
+  }
+  if (workerPaths["css"]) {
+    workerPaths["less"] = workerPaths["css"];
+    workerPaths["scss"] = workerPaths["css"];
+  }
+  if (workerPaths["html"]) {
+    workerPaths["handlebars"] = workerPaths["html"];
+    workerPaths["razor"] = workerPaths["html"];
+  }
+  return workerPaths;
+}
+function workerMiddleware(middlewares, config, options) {
+  const works = getWorks(options);
+  if (fs.existsSync(cacheDir)) {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+  for (const work of works) {
+    middlewares.use(
+      config.base + options.publicPath + "/" + getFilenameByEntry(work.entry),
+      function(req, res, next) {
+        if (!fs.existsSync(cacheDir + getFilenameByEntry(work.entry))) {
+          esbuild.buildSync({
+            entryPoints: [resolveMonacoPath(work.entry)],
+            bundle: true,
+            outfile: cacheDir + getFilenameByEntry(work.entry)
+          });
+        }
+        const contentBuffer = fs.readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        res.setHeader("Content-Type", "text/javascript");
+        res.end(contentBuffer);
+      }
+    );
+  }
+}
+function resolveMonacoPath(filePath) {
+  try {
+    return path.resolve(path.join(process.cwd(), "node_modules", filePath));
+  } catch (err) {
+    return path.resolve(filePath);
+  }
+}
+function getWorks(options) {
+  let works = options.languageWorkers.map(
+    (work) => languageWorksByLabel[work]
+  );
+  works.push(...options.customWorkers);
+  return works;
+}
+const getFS = async () => {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    const fs2 = await import("fs");
+    return {
+      existsSync: fs2.existsSync,
+      mkdirSync: fs2.mkdirSync,
+      readFileSync: fs2.readFileSync,
+      writeFileSync: fs2.writeFileSync
+    };
+  }
+  return null;
+};
+function monacoEditorPlugin(options) {
+  const languageWorkers = options.languageWorkers || Object.keys(languageWorksByLabel);
+  const publicPath = options.publicPath || "monacoeditorwork";
+  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];
+              var _location = window.__MICRO_APP_ENVIRONMENT__ ? window.rawWindow.location : window.location;
+              var currentUrl = String(_location);
+              var currentOrigin = currentUrl.substr(0, currentUrl.length - _location.hash.length - _location.search.length - _location.pathname.length);
+              
+              if (window.__MICRO_APP_ENVIRONMENT__) {
+                result =  currentOrigin + result.replace('./', '/')
+              }
+              
+              if (/^((http:)|(https:)|(file:)|(\\/\\/))/.test(result)) {
+                if (result.substring(0, currentOrigin.length) !== currentOrigin) {
+                  var js = '/*' + label + '*/importScripts("' + result + '");';
+                  var blob = new Blob([js], { type: 'application/javascript' });
+                  return URL.createObjectURL(blob);
+                }
+              }
+              console.log('result',result);
+              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;
+    },
+    async writeBundle() {
+      if (isCDN(publicPath) && !forceBuildCDN) {
+        return;
+      }
+      const fs2 = await getFS();
+      if (!fs2) {
+        this.warn("File system operations not available in this environment");
+        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
+      );
+      if (!fs2.existsSync(distPath)) {
+        fs2.mkdirSync(distPath, {
+          recursive: true
+        });
+      }
+      for (const work of works) {
+        if (!fs2.existsSync(cacheDir + getFilenameByEntry(work.entry))) {
+          esbuild.buildSync({
+            entryPoints: [resolveMonacoPath(work.entry)],
+            bundle: true,
+            outfile: cacheDir + getFilenameByEntry(work.entry)
+          });
+        }
+        const contentBuffer = fs2.readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        const workDistPath = path.resolve(distPath, getFilenameByEntry(work.entry));
+        fs2.writeFileSync(workDistPath, contentBuffer);
+      }
+    }
+  };
+}
+function isCDN(publicPath) {
+  if (/^((http:)|(https:)|(file:)|(\/\/))/.test(publicPath)) {
+    return true;
+  }
+  return false;
+}
+function matches(filename, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  return patterns.some(
+    (p) => typeof p === "string" ? filename.includes(p) : p.test(filename)
+  );
+}
+function sharpOptimize(options = {}) {
+  const {
+    include,
+    exclude,
+    jpegQuality = 75,
+    pngQuality = 75,
+    webpQuality = 75,
+    avifQuality = 50
+  } = options;
+  let _sharp = null;
+  const getSharp = async () => {
+    if (!_sharp) {
+      const sharpModule = await import("sharp");
+      _sharp = sharpModule.default ?? sharpModule;
+    }
+    return _sharp;
+  };
+  const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".avif"]);
+  return {
+    name: "jetlinks-sharp-optimize",
+    apply: "build",
+    enforce: "post",
+    async generateBundle(_opts, bundle) {
+      for (const [fileName, asset] of Object.entries(bundle)) {
+        if (asset.type !== "asset") continue;
+        const ext = path$1.extname(fileName).toLowerCase();
+        if (!imageExts.has(ext)) continue;
+        if (exclude && matches(fileName, exclude)) continue;
+        if (include && !matches(fileName, include)) continue;
+        try {
+          const sourceBuffer = Buffer.isBuffer(asset.source) ? asset.source : Buffer.from(String(asset.source));
+          const sharp = await getSharp();
+          let instance = sharp(sourceBuffer);
+          switch (ext) {
+            case ".jpg":
+            case ".jpeg":
+              instance = instance.jpeg({ quality: jpegQuality, mozjpeg: true });
+              break;
+            case ".png":
+              instance = instance.png({ quality: pngQuality, compressionLevel: 9 });
+              break;
+            case ".webp":
+              instance = instance.webp({ quality: webpQuality });
+              break;
+            case ".avif":
+              instance = instance.avif({ quality: avifQuality });
+              break;
+            default:
+              break;
+          }
+          const optimized = await instance.toBuffer();
+          asset.source = optimized;
+        } catch (err) {
+          this.warn(`sharp optimize failed for ${fileName}: ${String(err)}`);
+        }
+      }
+    }
+  };
+}
+exports.federation = federation;
+exports.monacoEditorPlugin = monacoEditorPlugin;
+exports.sharpOptimize = sharpOptimize;

package/dist/index.mjs

@@ -3,16 +3,16 @@ import path, { posix, resolve, basename, join, extname, parse, relative, dirname
 import { walk } from "estree-walker";
 import MagicString from "magic-string";
 import path$1 from "node:path";
-import { readFileSync, statSync, readdirSync } from "fs";
+import { readFileSync, statSync, readdirSync, existsSync, rmSync } from "fs";
 import "crypto";
-import { DynamicRemoteManager, dynamicRemoteManager, loadDynamicRemoteComponent, useDynamicRemote } from "./dynamic-remote.mjs";
+import "./dynamic-remote.mjs";
+import { buildSync } from "esbuild";
 const EXPOSES_MAP = /* @__PURE__ */ new Map();
 const EXPOSES_KEY_MAP = /* @__PURE__ */ new Map();
 const SHARED = "shared";
 const DYNAMIC_LOADING_CSS = "dynamicLoadingCss";
 const DYNAMIC_LOADING_CSS_PREFIX = "__v__css__";
 const DEFAULT_ENTRY_FILENAME = "remoteEntry.js";
-const VitePluginFederationVersion = "1.5.0";
 const builderInfo = {
   builder: "rollup",
   assetsDir: "",
@@ -1792,11 +1792,286 @@ function federation(options) {
     }
   };
 }
+const languageWorkAttr = [
+  {
+    label: "editorWorkerService",
+    entry: "monaco-editor/esm/vs/editor/editor.worker"
+  },
+  {
+    label: "css",
+    entry: "monaco-editor/esm/vs/language/css/css.worker"
+  },
+  {
+    label: "html",
+    entry: "monaco-editor/esm/vs/language/html/html.worker"
+  },
+  {
+    label: "json",
+    entry: "monaco-editor/esm/vs/language/json/json.worker"
+  },
+  {
+    label: "typescript",
+    entry: "monaco-editor/esm/vs/language/typescript/ts.worker"
+  }
+];
+const languageWorksByLabel = {};
+languageWorkAttr.forEach(
+  (languageWork) => languageWorksByLabel[languageWork.label] = languageWork
+);
+function getFilenameByEntry(entry) {
+  entry = basename(entry, "js");
+  return entry + ".bundle.js";
+}
+const cacheDir = "node_modules/.monaco/";
+function getWorkPath(works, options, config) {
+  const workerPaths = {};
+  for (const work of works) {
+    if (isCDN(options.publicPath)) {
+      workerPaths[work.label] = options.publicPath + "/" + getFilenameByEntry(work.entry);
+    } else {
+      workerPaths[work.label] = config.base + options.publicPath + "/" + getFilenameByEntry(work.entry);
+    }
+  }
+  if (workerPaths["typescript"]) {
+    workerPaths["javascript"] = workerPaths["typescript"];
+  }
+  if (workerPaths["css"]) {
+    workerPaths["less"] = workerPaths["css"];
+    workerPaths["scss"] = workerPaths["css"];
+  }
+  if (workerPaths["html"]) {
+    workerPaths["handlebars"] = workerPaths["html"];
+    workerPaths["razor"] = workerPaths["html"];
+  }
+  return workerPaths;
+}
+function workerMiddleware(middlewares, config, options) {
+  const works = getWorks(options);
+  if (existsSync(cacheDir)) {
+    rmSync(cacheDir, { recursive: true, force: true });
+  }
+  for (const work of works) {
+    middlewares.use(
+      config.base + options.publicPath + "/" + getFilenameByEntry(work.entry),
+      function(req, res, next) {
+        if (!existsSync(cacheDir + getFilenameByEntry(work.entry))) {
+          buildSync({
+            entryPoints: [resolveMonacoPath(work.entry)],
+            bundle: true,
+            outfile: cacheDir + getFilenameByEntry(work.entry)
+          });
+        }
+        const contentBuffer = readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        res.setHeader("Content-Type", "text/javascript");
+        res.end(contentBuffer);
+      }
+    );
+  }
+}
+function resolveMonacoPath(filePath) {
+  try {
+    return resolve(join(process.cwd(), "node_modules", filePath));
+  } catch (err) {
+    return resolve(filePath);
+  }
+}
+function getWorks(options) {
+  let works = options.languageWorkers.map(
+    (work) => languageWorksByLabel[work]
+  );
+  works.push(...options.customWorkers);
+  return works;
+}
+const getFS = async () => {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    const fs = await import("fs");
+    return {
+      existsSync: fs.existsSync,
+      mkdirSync: fs.mkdirSync,
+      readFileSync: fs.readFileSync,
+      writeFileSync: fs.writeFileSync
+    };
+  }
+  return null;
+};
+function monacoEditorPlugin(options) {
+  const languageWorkers = options.languageWorkers || Object.keys(languageWorksByLabel);
+  const publicPath = options.publicPath || "monacoeditorwork";
+  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];
+              var _location = window.__MICRO_APP_ENVIRONMENT__ ? window.rawWindow.location : window.location;
+              var currentUrl = String(_location);
+              var currentOrigin = currentUrl.substr(0, currentUrl.length - _location.hash.length - _location.search.length - _location.pathname.length);
+              
+              if (window.__MICRO_APP_ENVIRONMENT__) {
+                result =  currentOrigin + result.replace('./', '/')
+              }
+              
+              if (/^((http:)|(https:)|(file:)|(\\/\\/))/.test(result)) {
+                if (result.substring(0, currentOrigin.length) !== currentOrigin) {
+                  var js = '/*' + label + '*/importScripts("' + result + '");';
+                  var blob = new Blob([js], { type: 'application/javascript' });
+                  return URL.createObjectURL(blob);
+                }
+              }
+              console.log('result',result);
+              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;
+    },
+    async writeBundle() {
+      if (isCDN(publicPath) && !forceBuildCDN) {
+        return;
+      }
+      const fs = await getFS();
+      if (!fs) {
+        this.warn("File system operations not available in this environment");
+        return;
+      }
+      const works = getWorks(options);
+      const distPath = options.customDistPath ? options.customDistPath(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        resolvedConfig.base
+      ) : join(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        resolvedConfig.base,
+        options.publicPath
+      );
+      if (!fs.existsSync(distPath)) {
+        fs.mkdirSync(distPath, {
+          recursive: true
+        });
+      }
+      for (const work of works) {
+        if (!fs.existsSync(cacheDir + getFilenameByEntry(work.entry))) {
+          buildSync({
+            entryPoints: [resolveMonacoPath(work.entry)],
+            bundle: true,
+            outfile: cacheDir + getFilenameByEntry(work.entry)
+          });
+        }
+        const contentBuffer = fs.readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        const workDistPath = resolve(distPath, getFilenameByEntry(work.entry));
+        fs.writeFileSync(workDistPath, contentBuffer);
+      }
+    }
+  };
+}
+function isCDN(publicPath) {
+  if (/^((http:)|(https:)|(file:)|(\/\/))/.test(publicPath)) {
+    return true;
+  }
+  return false;
+}
+function matches(filename, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  return patterns.some(
+    (p) => typeof p === "string" ? filename.includes(p) : p.test(filename)
+  );
+}
+function sharpOptimize(options = {}) {
+  const {
+    include,
+    exclude,
+    jpegQuality = 75,
+    pngQuality = 75,
+    webpQuality = 75,
+    avifQuality = 50
+  } = options;
+  let _sharp = null;
+  const getSharp = async () => {
+    if (!_sharp) {
+      const sharpModule = await import("sharp");
+      _sharp = sharpModule.default ?? sharpModule;
+    }
+    return _sharp;
+  };
+  const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".avif"]);
+  return {
+    name: "jetlinks-sharp-optimize",
+    apply: "build",
+    enforce: "post",
+    async generateBundle(_opts, bundle) {
+      for (const [fileName, asset] of Object.entries(bundle)) {
+        if (asset.type !== "asset") continue;
+        const ext = path$1.extname(fileName).toLowerCase();
+        if (!imageExts.has(ext)) continue;
+        if (exclude && matches(fileName, exclude)) continue;
+        if (include && !matches(fileName, include)) continue;
+        try {
+          const sourceBuffer = Buffer.isBuffer(asset.source) ? asset.source : Buffer.from(String(asset.source));
+          const sharp = await getSharp();
+          let instance = sharp(sourceBuffer);
+          switch (ext) {
+            case ".jpg":
+            case ".jpeg":
+              instance = instance.jpeg({ quality: jpegQuality, mozjpeg: true });
+              break;
+            case ".png":
+              instance = instance.png({ quality: pngQuality, compressionLevel: 9 });
+              break;
+            case ".webp":
+              instance = instance.webp({ quality: webpQuality });
+              break;
+            case ".avif":
+              instance = instance.avif({ quality: avifQuality });
+              break;
+            default:
+              break;
+          }
+          const optimized = await instance.toBuffer();
+          asset.source = optimized;
+        } catch (err) {
+          this.warn(`sharp optimize failed for ${fileName}: ${String(err)}`);
+        }
+      }
+    }
+  };
+}
 export {
-  DynamicRemoteManager,
-  VitePluginFederationVersion,
-  federation as default,
-  dynamicRemoteManager,
-  loadDynamicRemoteComponent,
-  useDynamicRemote
+  federation,
+  monacoEditorPlugin,
+  sharpOptimize
 };

package/dist/satisfy.d.ts

@@ -1,2 +1,3 @@
-export { satisfy } from './src/utils/semver/satisfy';
-//# sourceMappingURL=satisfy.d.ts.map
+export declare function satisfy(version: string, range: string): boolean;
+
+export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meethive/vite",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",