vanilla-native-federation/fesm2022/options.mjs

A lightweight **runtime micro frontend orchestrator** that loads micro frontends built with native federation into any web page. It can cache dependencies across page reloads, making it perfect for traditional server-rendered hosts (PHP, Java, Rails, etc.

// src/lib/2.app/config/log.contract.ts
var LogLevel = {
  debug: 0,
  warn: 1,
  error: 2
};

// src/lib/4.config/logging/console.logger.ts
var consoleLogger = {
  /* eslint no-console: "off", curly: "error" */
  debug: (step, msg, err) => !!err ? console.log(`[DEBUG][${step}]: ${msg}`, err) : console.log(`[DEBUG][${step}]: ${msg}`),
  error: (step, msg, err) => !!err ? console.error(`[NF][${step}]: ${msg}`, err) : console.error(`[NF][${step}]: ${msg}`),
  warn: (step, msg, err) => !!err ? console.warn(`[NF][${step}]: ${msg}`, err) : console.warn(`[NF][${step}]: ${msg}`)
};

// src/lib/4.config/logging/noop.logger.ts
var noopLogger = {
  debug: () => {
  },
  error: () => {
  },
  warn: () => {
  }
};

// src/lib/native-federation.error.ts
var NFError = class extends Error {
  constructor(message, cause) {
    super(message, cause);
    this.name = "NFError";
  }
};

// src/lib/utils/clone-entry.ts
var cloneEntry = (name, raw) => {
  try {
    if (typeof structuredClone === "function") {
      return structuredClone(raw);
    }
  } catch {
  }
  try {
    return JSON.parse(JSON.stringify(raw));
  } catch {
  }
  throw new NFError(`Could not parse storage entry '${String(name)}'`);
};

// src/lib/4.config/storage/global-this.storage.ts
var globalThisStorageEntry = (namespace) => (key, initialValue) => {
  if (!globalThis[namespace]) {
    globalThis[namespace] = {};
  }
  const storage = globalThis[namespace];
  if (!storage[key]) storage[key] = initialValue;
  const entry = {
    get() {
      return cloneEntry(key, storage[key]);
    },
    set(value) {
      storage[key] = cloneEntry(key, value);
      return entry;
    },
    clear() {
      storage[key] = cloneEntry(key, initialValue);
      return this;
    }
  };
  return entry;
};

// src/lib/4.config/storage/local.storage.ts
var localStorageEntry = (namespace) => (key, initialValue) => {
  if (!localStorage.getItem(`${namespace}.${String(key)}`)) {
    localStorage.setItem(`${namespace}.${String(key)}`, JSON.stringify(initialValue));
  }
  const entry = {
    get() {
      const fromCache = localStorage.getItem(`${namespace}.${String(key)}`);
      if (!fromCache) return void 0;
      return JSON.parse(fromCache);
    },
    set(value) {
      localStorage.setItem(`${namespace}.${String(key)}`, JSON.stringify(value));
      return entry;
    },
    clear() {
      localStorage.setItem(`${namespace}.${String(key)}`, JSON.stringify(initialValue));
      return this;
    }
  };
  return entry;
};

// src/lib/4.config/storage/session.storage.ts
var sessionStorageEntry = (namespace) => (key, initialValue) => {
  if (!sessionStorage.getItem(`${namespace}.${String(key)}`)) {
    sessionStorage.setItem(`${namespace}.${String(key)}`, JSON.stringify(initialValue));
  }
  const entry = {
    get() {
      const fromCache = sessionStorage.getItem(`${namespace}.${String(key)}`);
      if (!fromCache) return void 0;
      return JSON.parse(fromCache);
    },
    set(value) {
      sessionStorage.setItem(`${namespace}.${String(key)}`, JSON.stringify(value));
      return entry;
    },
    clear() {
      sessionStorage.setItem(`${namespace}.${String(key)}`, JSON.stringify(initialValue));
      return this;
    }
  };
  return entry;
};

// src/lib/4.config/import-map/replace-in-dom.ts
var replaceInDOM = (mapType) => (importMap, opts = {}) => {
  if (opts?.override) {
    document.head.querySelectorAll(`script[type="${mapType}"]`).forEach((importMap2) => importMap2.remove());
  }
  document.head.appendChild(
    Object.assign(document.createElement("script"), {
      type: mapType,
      innerHTML: JSON.stringify(importMap)
    })
  );
  return Promise.resolve(importMap);
};

// src/lib/4.config/import-map/use-import-shim.ts
var useShimImportMap = (cfg = { shimMode: false }) => ({
  loadModuleFn: (url) => importShim(url),
  setImportMapFn: replaceInDOM(cfg.shimMode ? "importmap-shim" : "importmap")
});

// src/lib/4.config/import-map/use-default.ts
var useDefaultImportMap = () => ({
  loadModuleFn: (url) => import(
    /* @vite-ignore */
    url
  ),
  setImportMapFn: replaceInDOM("importmap")
});

// src/lib/4.config/mode/default.profile.ts
var defaultProfile = {
  latestSharedExternal: false,
  overrideCachedRemotes: "init-only",
  overrideCachedRemotesIfURLMatches: false
};

// src/lib/4.config/mode/caching.profile.ts
var cachingProfile = {
  latestSharedExternal: false,
  overrideCachedRemotes: "never",
  overrideCachedRemotesIfURLMatches: false
};
export {
  LogLevel,
  cachingProfile,
  consoleLogger,
  defaultProfile,
  globalThisStorageEntry,
  localStorageEntry,
  noopLogger,
  replaceInDOM,
  sessionStorageEntry,
  useDefaultImportMap,
  useShimImportMap
};
//# sourceMappingURL=options.mjs.map