@meethive/vite 0.0.1 → 0.0.3

package/dist/{src/federation/src/runtime/dynamic-remote.d.ts → dynamic-remote.d.ts}

@@ -1,21 +1,3 @@
-/**
- * Dynamic remote loader for runtime
- * Provides utilities to dynamically load and manage remote components at runtime
- */
-export interface RemoteOptions {
-    url: string | (() => string | Promise<string>);
-    format?: 'esm' | 'systemjs' | 'var';
-    from?: 'vite' | 'webpack';
-    shareScope?: string;
-    external?: string | string[];
-    externalType?: 'url' | 'promise';
-}
-export interface RemoteComponentConfig {
-    name: string;
-    component: string;
-    url: string | (() => string | Promise<string>);
-    options?: RemoteOptions;
-}
 /**
  * Dynamic remote component manager
  */
@@ -59,12 +41,35 @@ export declare class DynamicRemoteManager {
      */
     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
@@ -76,4 +81,5 @@ export declare function useDynamicRemote(remoteName: string, componentName: stri
     error: any;
     reload: () => Promise<void>;
 };
-//# sourceMappingURL=dynamic-remote.d.ts.map
+
+export { }

package/dist/dynamic-remote.js

@@ -0,0 +1,185 @@
+"use strict";
+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" });
+class DynamicRemoteManager {
+  remoteCache = /* @__PURE__ */ new Map();
+  loadingPromises = /* @__PURE__ */ new Map();
+  /**
+   * Add a remote dynamically at runtime
+   * @param name Remote name
+   * @param config Remote configuration
+   */
+  async addRemote(name, config) {
+    try {
+      const federationModule = await import("virtual:__federation__");
+      const { __federation_method_add_origin_setRemote } = federationModule;
+      await __federation_method_add_origin_setRemote(name, config.url, {
+        format: config.format || "esm",
+        from: config.from || "vite",
+        shareScope: config.shareScope || "default",
+        external: config.external,
+        externalType: config.externalType || "url"
+      });
+    } catch (error) {
+      throw new Error(`Failed to add dynamic remote '${name}': ${error.message}. Make sure to enable dynamic remotes in your plugin configuration with 'enableDynamicRemotes: true'.`);
+    }
+  }
+  /**
+   * Load a remote component dynamically
+   * @param remoteName Remote name
+   * @param componentName Component name to load from remote
+   * @returns Promise of the loaded component
+   */
+  async loadRemoteComponent(remoteName, componentName) {
+    const cacheKey = `${remoteName}/${componentName}`;
+    if (this.remoteCache.has(cacheKey)) {
+      return this.remoteCache.get(cacheKey);
+    }
+    if (this.loadingPromises.has(cacheKey)) {
+      return this.loadingPromises.get(cacheKey);
+    }
+    const loadingPromise = this.doLoadRemoteComponent(remoteName, componentName);
+    this.loadingPromises.set(cacheKey, loadingPromise);
+    try {
+      const component = await loadingPromise;
+      this.remoteCache.set(cacheKey, component);
+      return component;
+    } finally {
+      this.loadingPromises.delete(cacheKey);
+    }
+  }
+  async doLoadRemoteComponent(remoteName, componentName) {
+    try {
+      const federationModule = await import("virtual:__federation__");
+      const { __federation_method_getRemote } = federationModule;
+      return __federation_method_getRemote(remoteName, componentName);
+    } catch (error) {
+      throw new Error(`Failed to load remote component '${remoteName}/${componentName}': ${error.message}. Make sure to enable dynamic remotes in your plugin configuration with 'enableDynamicRemotes: true'.`);
+    }
+  }
+  /**
+   * Preload a remote component
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  async preloadRemoteComponent(remoteName, componentName) {
+    try {
+      await this.loadRemoteComponent(remoteName, componentName);
+    } catch (error) {
+      console.warn(`Failed to preload remote component ${remoteName}/${componentName}:`, error);
+    }
+  }
+  /**
+   * Remove a remote component from cache
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  clearRemoteComponentCache(remoteName, componentName) {
+    if (componentName) {
+      const cacheKey = `${remoteName}/${componentName}`;
+      this.remoteCache.delete(cacheKey);
+    } else {
+      for (const key of this.remoteCache.keys()) {
+        if (key.startsWith(`${remoteName}/`)) {
+          this.remoteCache.delete(key);
+        }
+      }
+    }
+  }
+  /**
+   * Get all cached remote components
+   */
+  getCachedRemotes() {
+    return Array.from(this.remoteCache.keys());
+  }
+  /**
+   * Check if a remote component is cached
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  isRemoteComponentCached(remoteName, componentName) {
+    const cacheKey = `${remoteName}/${componentName}`;
+    return this.remoteCache.has(cacheKey);
+  }
+}
+const dynamicRemoteManager = new DynamicRemoteManager();
+async function loadDynamicRemoteComponent(config) {
+  if (config.options) {
+    await dynamicRemoteManager.addRemote(config.name, {
+      url: config.url,
+      ...config.options
+    });
+  }
+  return dynamicRemoteManager.loadRemoteComponent(config.name, config.component);
+}
+function useDynamicRemote(remoteName, componentName) {
+  const loading = ref(true);
+  const error = ref(null);
+  const component = ref(null);
+  const loadComponent = async () => {
+    try {
+      loading.value = true;
+      error.value = null;
+      component.value = await dynamicRemoteManager.loadRemoteComponent(remoteName, componentName);
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error("Failed to load remote component");
+      console.error(`Failed to load remote component ${remoteName}/${componentName}:`, err);
+    } finally {
+      loading.value = false;
+    }
+  };
+  onMounted(() => {
+    loadComponent();
+  });
+  return {
+    component: readonly(component),
+    loading: readonly(loading),
+    error: readonly(error),
+    reload: loadComponent
+  };
+}
+function isVueAvailable() {
+  try {
+    return typeof ref !== "undefined" && typeof onMounted !== "undefined";
+  } catch {
+    return false;
+  }
+}
+let ref, onMounted, readonly;
+if (isVueAvailable()) {
+  try {
+    import("vue").then((vue) => {
+      ref = vue.ref;
+      onMounted = vue.onMounted;
+      readonly = vue.readonly;
+    }).catch(() => {
+      console.warn("Vue not available for dynamic import");
+    });
+  } catch {
+  }
+}
+exports.DynamicRemoteManager = DynamicRemoteManager;
+exports.dynamicRemoteManager = dynamicRemoteManager;
+exports.loadDynamicRemoteComponent = loadDynamicRemoteComponent;
+exports.useDynamicRemote = useDynamicRemote;

package/dist/dynamic-remote.mjs

@@ -0,0 +1,163 @@
+class DynamicRemoteManager {
+  remoteCache = /* @__PURE__ */ new Map();
+  loadingPromises = /* @__PURE__ */ new Map();
+  /**
+   * Add a remote dynamically at runtime
+   * @param name Remote name
+   * @param config Remote configuration
+   */
+  async addRemote(name, config) {
+    try {
+      const federationModule = await import("virtual:__federation__");
+      const { __federation_method_add_origin_setRemote } = federationModule;
+      await __federation_method_add_origin_setRemote(name, config.url, {
+        format: config.format || "esm",
+        from: config.from || "vite",
+        shareScope: config.shareScope || "default",
+        external: config.external,
+        externalType: config.externalType || "url"
+      });
+    } catch (error) {
+      throw new Error(`Failed to add dynamic remote '${name}': ${error.message}. Make sure to enable dynamic remotes in your plugin configuration with 'enableDynamicRemotes: true'.`);
+    }
+  }
+  /**
+   * Load a remote component dynamically
+   * @param remoteName Remote name
+   * @param componentName Component name to load from remote
+   * @returns Promise of the loaded component
+   */
+  async loadRemoteComponent(remoteName, componentName) {
+    const cacheKey = `${remoteName}/${componentName}`;
+    if (this.remoteCache.has(cacheKey)) {
+      return this.remoteCache.get(cacheKey);
+    }
+    if (this.loadingPromises.has(cacheKey)) {
+      return this.loadingPromises.get(cacheKey);
+    }
+    const loadingPromise = this.doLoadRemoteComponent(remoteName, componentName);
+    this.loadingPromises.set(cacheKey, loadingPromise);
+    try {
+      const component = await loadingPromise;
+      this.remoteCache.set(cacheKey, component);
+      return component;
+    } finally {
+      this.loadingPromises.delete(cacheKey);
+    }
+  }
+  async doLoadRemoteComponent(remoteName, componentName) {
+    try {
+      const federationModule = await import("virtual:__federation__");
+      const { __federation_method_getRemote } = federationModule;
+      return __federation_method_getRemote(remoteName, componentName);
+    } catch (error) {
+      throw new Error(`Failed to load remote component '${remoteName}/${componentName}': ${error.message}. Make sure to enable dynamic remotes in your plugin configuration with 'enableDynamicRemotes: true'.`);
+    }
+  }
+  /**
+   * Preload a remote component
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  async preloadRemoteComponent(remoteName, componentName) {
+    try {
+      await this.loadRemoteComponent(remoteName, componentName);
+    } catch (error) {
+      console.warn(`Failed to preload remote component ${remoteName}/${componentName}:`, error);
+    }
+  }
+  /**
+   * Remove a remote component from cache
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  clearRemoteComponentCache(remoteName, componentName) {
+    if (componentName) {
+      const cacheKey = `${remoteName}/${componentName}`;
+      this.remoteCache.delete(cacheKey);
+    } else {
+      for (const key of this.remoteCache.keys()) {
+        if (key.startsWith(`${remoteName}/`)) {
+          this.remoteCache.delete(key);
+        }
+      }
+    }
+  }
+  /**
+   * Get all cached remote components
+   */
+  getCachedRemotes() {
+    return Array.from(this.remoteCache.keys());
+  }
+  /**
+   * Check if a remote component is cached
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  isRemoteComponentCached(remoteName, componentName) {
+    const cacheKey = `${remoteName}/${componentName}`;
+    return this.remoteCache.has(cacheKey);
+  }
+}
+const dynamicRemoteManager = new DynamicRemoteManager();
+async function loadDynamicRemoteComponent(config) {
+  if (config.options) {
+    await dynamicRemoteManager.addRemote(config.name, {
+      url: config.url,
+      ...config.options
+    });
+  }
+  return dynamicRemoteManager.loadRemoteComponent(config.name, config.component);
+}
+function useDynamicRemote(remoteName, componentName) {
+  const loading = ref(true);
+  const error = ref(null);
+  const component = ref(null);
+  const loadComponent = async () => {
+    try {
+      loading.value = true;
+      error.value = null;
+      component.value = await dynamicRemoteManager.loadRemoteComponent(remoteName, componentName);
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error("Failed to load remote component");
+      console.error(`Failed to load remote component ${remoteName}/${componentName}:`, err);
+    } finally {
+      loading.value = false;
+    }
+  };
+  onMounted(() => {
+    loadComponent();
+  });
+  return {
+    component: readonly(component),
+    loading: readonly(loading),
+    error: readonly(error),
+    reload: loadComponent
+  };
+}
+function isVueAvailable() {
+  try {
+    return typeof ref !== "undefined" && typeof onMounted !== "undefined";
+  } catch {
+    return false;
+  }
+}
+let ref, onMounted, readonly;
+if (isVueAvailable()) {
+  try {
+    import("vue").then((vue) => {
+      ref = vue.ref;
+      onMounted = vue.onMounted;
+      readonly = vue.readonly;
+    }).catch(() => {
+      console.warn("Vue not available for dynamic import");
+    });
+  } catch {
+  }
+}
+export {
+  DynamicRemoteManager,
+  dynamicRemoteManager,
+  loadDynamicRemoteComponent,
+  useDynamicRemote
+};

package/dist/index.d.ts

@@ -1,4 +1,51 @@
-export { default as federation } from './src/federation/src';
-export { default as monacoEditorPlugin } from './src/monaco-editor';
-export { default as sharpOptimize } from './src/sharp';
-//# 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

@@ -29,6 +29,7 @@ const MagicString = require("magic-string");
 const path$1 = require("node:path");
 const fs = require("fs");
 require("crypto");
+require("./dynamic-remote.js");
 const esbuild = require("esbuild");
 const EXPOSES_MAP = /* @__PURE__ */ new Map();
 const EXPOSES_KEY_MAP = /* @__PURE__ */ new Map();
@@ -1652,26 +1653,6 @@ function devExposePlugin(options) {
     name: "originjs:expose-development"
   };
 }
-function isVueAvailable() {
-  try {
-    return typeof ref !== "undefined" && typeof onMounted !== "undefined";
-  } catch {
-    return false;
-  }
-}
-let ref, onMounted, readonly;
-if (isVueAvailable()) {
-  try {
-    import("vue").then((vue) => {
-      ref = vue.ref;
-      onMounted = vue.onMounted;
-      readonly = vue.readonly;
-    }).catch(() => {
-      console.warn("Vue not available for dynamic import");
-    });
-  } catch {
-  }
-}
 const normalizeAssetsDir = (config) => {
   const configured = config?.build?.assetsDir ?? "assets";
   if (!configured) return "";

package/dist/index.mjs

@@ -5,6 +5,7 @@ import MagicString from "magic-string";
 import path$1 from "node:path";
 import { readFileSync, statSync, readdirSync, existsSync, rmSync } from "fs";
 import "crypto";
+import "./dynamic-remote.mjs";
 import { buildSync } from "esbuild";
 const EXPOSES_MAP = /* @__PURE__ */ new Map();
 const EXPOSES_KEY_MAP = /* @__PURE__ */ new Map();
@@ -1628,26 +1629,6 @@ function devExposePlugin(options) {
     name: "originjs:expose-development"
   };
 }
-function isVueAvailable() {
-  try {
-    return typeof ref !== "undefined" && typeof onMounted !== "undefined";
-  } catch {
-    return false;
-  }
-}
-let ref, onMounted, readonly;
-if (isVueAvailable()) {
-  try {
-    import("vue").then((vue) => {
-      ref = vue.ref;
-      onMounted = vue.onMounted;
-      readonly = vue.readonly;
-    }).catch(() => {
-      console.warn("Vue not available for dynamic import");
-    });
-  } catch {
-  }
-}
 const normalizeAssetsDir = (config) => {
   const configured = config?.build?.assetsDir ?? "assets";
   if (!configured) return "";

package/dist/{src/federation/src/utils/semver/satisfy.d.ts → satisfy.d.ts}

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