@meethive/vite 0.0.1 → 0.0.2

package/dist/dynamic-remote.d.ts

@@ -0,0 +1,2 @@
+export * from './src/runtime/dynamic-remote';
+//# sourceMappingURL=dynamic-remote.d.ts.map

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,3 @@
-export { default as federation } from './src/federation/src';
-export { default as monacoEditorPlugin } from './src/monaco-editor';
-export { default as sharpOptimize } from './src/sharp';
+export { default } from './src';
+export * from './src';
 //# sourceMappingURL=index.d.ts.map