intor 2.2.0 → 2.2.2

package/dist/next/index.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
-var React7 = require('react');
+var React6 = require('react');
 var logry = require('logry');
 var Keyv = require('keyv');
+var merge = require('lodash.merge');
 var intorTranslator = require('intor-translator');
 var formatUrl = require('next/dist/shared/lib/router/utils/format-url');
 var NextLink = require('next/link');
@@ -29,26 +30,27 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React7__namespace = /*#__PURE__*/_interopNamespace(React7);
+var React6__namespace = /*#__PURE__*/_interopNamespace(React6);
 var Keyv__default = /*#__PURE__*/_interopDefault(Keyv);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
 var NextLink__default = /*#__PURE__*/_interopDefault(NextLink);
 
 // src/adapters/next/contexts/intor-provider/intor-provider.tsx
-var ConfigContext = React7__namespace.createContext(void 0);
+var ConfigContext = React6__namespace.createContext(void 0);
+
+// src/adapters/next/contexts/config/provider.tsx
 function ConfigProvider({
   value: { config, pathname },
   children
 }) {
-  const value = React7__namespace.useMemo(() => ({ config, pathname }), [config, pathname]);
-  return /* @__PURE__ */ React7__namespace.createElement(ConfigContext.Provider, { value }, children);
+  const value = React6__namespace.useMemo(() => ({ config, pathname }), [config, pathname]);
+  return /* @__PURE__ */ React6__namespace.createElement(ConfigContext.Provider, { value }, children);
 }
 function useConfig() {
-  const context = React7__namespace.useContext(ConfigContext);
+  const context = React6__namespace.useContext(ConfigContext);
   if (!context) throw new Error("useConfig must be used within ConfigProvider");
   return context;
 }
-var LocaleContext = React7__namespace.createContext(void 0);
-var MessagesContext = React7__namespace.createContext(void 0);
 
 // src/modules/config/constants/cache.constants.ts
 var DEFAULT_CACHE_OPTIONS = {
@@ -70,17 +72,18 @@ var DEFAULT_FORMATTER_CONFIG = {
   node: { meta: { compact: true }, lineBreaksAfter: 1 }
 };
 function getLogger({
-  id,
+  id = "default",
   formatterConfig,
   preset,
   ...options
 }) {
   const pool = getGlobalLoggerPool();
   let logger = pool.get(id);
+  const useDefault = !formatterConfig && !preset;
   if (!logger) {
     logger = logry.logry({
       id,
-      formatterConfig: !formatterConfig && !preset ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
+      formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
       preset,
       ...options
     });
@@ -92,28 +95,36 @@ function getLogger({
   }
   return logger;
 }
+
+// src/modules/messages/shared/utils/is-namespace-messages.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNamespaceMessages(value) {
+  if (!isPlainObject(value)) return false;
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const v of Object.values(current)) {
+      if (typeof v === "string") continue;
+      if (isPlainObject(v)) {
+        stack.push(v);
+      } else {
+        return false;
+      }
+    }
+  }
+  return true;
+}
 function getGlobalMessagesPool() {
   if (!globalThis.__INTOR_MESSAGES_POOL__) {
     globalThis.__INTOR_MESSAGES_POOL__ = new Keyv__default.default();
   }
   return globalThis.__INTOR_MESSAGES_POOL__;
 }
-
-// src/shared/utils/merge-messages.ts
 var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  const result = Object.keys(staticMessages).length > 0 ? { ...staticMessages } : {};
-  for (const locale in loadedMessages) {
-    const loaded = loadedMessages[locale];
-    if (!result[locale]) {
-      result[locale] = loaded;
-      continue;
-    }
-    result[locale] = {
-      ...result[locale],
-      ...loaded
-    };
-  }
-  return result;
+  if (!loadedMessages) return { ...staticMessages };
+  return merge__default.default({}, staticMessages, loadedMessages);
 };
 
 // src/shared/utils/normalize-cache-key.ts
@@ -145,6 +156,8 @@ var resolveNamespaces = ({
 }) => {
   const { loader } = config;
   const { routeNamespaces = {}, namespaces } = loader || {};
+  if (Object.keys(routeNamespaces).length === 0 && !namespaces)
+    return void 0;
   const standardizedPathname = standardizePathname({ config, pathname });
   const placeholderRemovedPathname = standardizedPathname.replace(
     `/${PREFIX_PLACEHOLDER}`,
@@ -300,23 +313,23 @@ var standardizePathname = ({
   return normalizePathname(standardizedPathname);
 };
 
-// src/modules/messages/load-api-messages/fetch-messages.ts
-var fetchMessages = async ({
-  apiUrl,
-  apiHeaders,
-  locale,
+// src/modules/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.ts
+var fetchLocaleMessages = async ({
+  remoteUrl,
+  remoteHeaders,
   searchParams,
-  logger: loggerOptions = { id: "default" }
+  locale,
+  extraOptions: { loggerOptions } = {}
 }) => {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "fetch-messages" });
+  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
   try {
     const params = new URLSearchParams(searchParams);
     params.append("locale", locale);
-    const url = `${apiUrl}?${params.toString()}`;
+    const url = `${remoteUrl}?${params.toString()}`;
     const headers2 = {
       "Content-Type": "application/json",
-      ...apiHeaders
+      ...remoteHeaders
     };
     const response = await fetch(url, {
       method: "GET",
@@ -324,17 +337,17 @@ var fetchMessages = async ({
       cache: "no-store"
     });
     if (!response.ok) {
-      throw new Error(`Fetch failed: ${locale} (${response.status})`);
+      throw new Error(`HTTP error ${response.status} ${response.statusText}`);
     }
     const data = await response.json();
-    if (data == null || typeof data === "object" && Object.keys(data).length === 0) {
-      throw new Error(`Invalid messages: ${locale}`);
+    if (!isNamespaceMessages(data[locale])) {
+      throw new Error("JSON file does not match NamespaceMessages structure");
     }
     return data;
   } catch (error) {
-    logger.warn(`Failed to fetch messages for locale "${locale}".`, {
+    logger.warn("Fetching locale messages failed.", {
       locale,
-      apiUrl,
+      remoteUrl,
       searchParams: decodeURIComponent(searchParams.toString()),
       error
     });
@@ -342,30 +355,7 @@ var fetchMessages = async ({
   }
 };
 
-// src/modules/messages/load-api-messages/fetch-fallback-messages.ts
-var fetchFallbackMessages = async ({
-  apiUrl,
-  apiHeaders,
-  searchParams,
-  fallbackLocales,
-  logger
-}) => {
-  for (const fallbackLocale of fallbackLocales) {
-    const result = await fetchMessages({
-      apiUrl,
-      searchParams,
-      locale: fallbackLocale,
-      apiHeaders,
-      logger
-    });
-    if (result) {
-      return { locale: fallbackLocale, messages: result };
-    }
-  }
-  return;
-};
-
-// src/modules/messages/load-api-messages/utils/build-search-params.ts
+// src/modules/messages/load-remote-messages/fetch-locale-messages/utils/build-search-params.ts
 var buildSearchParams = (params) => {
   const searchParams = new URLSearchParams();
   const appendParam = (key, value) => {
@@ -383,78 +373,72 @@ var buildSearchParams = (params) => {
   return searchParams;
 };
 
-// src/modules/messages/load-api-messages/load-api-messages.ts
-var loadApiMessages = async ({
-  apiUrl,
-  apiHeaders,
-  basePath,
+// src/modules/messages/load-remote-messages/load-remote-messages.ts
+var loadRemoteMessages = async ({
+  pool = getGlobalMessagesPool(),
+  rootDir,
+  remoteUrl,
+  remoteHeaders,
   locale,
   fallbackLocales = [],
   namespaces = [],
-  cache = DEFAULT_CACHE_OPTIONS,
-  logger: loggerOptions = { id: "default" }
+  extraOptions: {
+    cacheOptions = DEFAULT_CACHE_OPTIONS,
+    loggerOptions = { id: "default" }
+  } = {}
 }) => {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-api-messages" });
-  if (!apiUrl) {
-    logger.warn("No apiUrl provided. Skipping fetch.");
-    return;
-  }
-  let pool;
-  if (cache.enabled) {
-    pool = getGlobalMessagesPool();
-  }
+  const logger = baseLogger.child({ scope: "load-remote-messages" });
+  const start = performance.now();
+  logger.debug("Loading remote messages from api.", { remoteUrl });
   const key = normalizeCacheKey([
     loggerOptions.id,
-    basePath,
+    "loaderType:remote",
+    rootDir,
     locale,
     (fallbackLocales ?? []).toSorted().join(","),
     (namespaces ?? []).toSorted().join(",")
   ]);
-  if (cache.enabled && key) {
+  if (cacheOptions.enabled && key) {
     const cached = await pool?.get(key);
     if (cached) {
       logger.debug("Messages cache hit.", { key });
       return cached;
     }
   }
-  const searchParams = buildSearchParams({ basePath, namespaces });
-  const messages = await fetchMessages({
-    apiUrl,
-    apiHeaders,
-    searchParams,
-    locale,
-    logger: loggerOptions
-  });
-  if (messages) {
-    if (cache.enabled && key) {
-      await pool?.set(key, messages, cache.ttl);
+  const searchParams = buildSearchParams({ rootDir, namespaces });
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    try {
+      const result = await fetchLocaleMessages({
+        remoteUrl,
+        remoteHeaders,
+        searchParams,
+        locale: candidateLocale,
+        extraOptions: { loggerOptions }
+      });
+      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
+        messages = result;
+        break;
+      }
+    } catch (error) {
+      logger.error("Failed to fetch locale messages.", {
+        locale: candidateLocale,
+        error
+      });
     }
-    return messages;
   }
-  const fallbackResult = await fetchFallbackMessages({
-    apiUrl,
-    apiHeaders,
-    searchParams,
-    fallbackLocales,
-    logger: loggerOptions
-  });
-  if (fallbackResult) {
-    logger.info("Fallback locale succeeded.", {
-      usedLocale: fallbackResult.locale,
-      apiUrl,
-      searchParams: decodeURIComponent(searchParams.toString())
-    });
-    if (cache.enabled && key) {
-      await pool?.set(key, fallbackResult.messages, cache.ttl);
-    }
-    return fallbackResult.messages;
+  if (cacheOptions.enabled && key && messages) {
+    await pool?.set(key, messages, cacheOptions.ttl);
   }
-  logger.warn("Failed to fetch messages for all locales.", {
-    locale,
-    fallbackLocales
+  const end = performance.now();
+  const duration = Math.round(end - start);
+  logger.trace("Finished loading remote messages.", {
+    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
+    duration: `${duration} ms`
   });
-  return;
+  return messages;
 };
 
 // src/adapters/next/contexts/messages/utils/use-refetch-messages.ts
@@ -465,20 +449,25 @@ var useRefetchMessages = ({
   setIsLoadingMessages
 }) => {
   const { messages: staticMessages } = config;
-  const namespaces = React7__namespace.useMemo(() => {
+  const namespaces = React6__namespace.useMemo(() => {
     if (!config.loader) return [];
     return resolveNamespaces({ config, pathname });
   }, [config, pathname]);
-  const refetchMessages = React7__namespace.useCallback(
+  const refetchMessages = React6__namespace.useCallback(
     async (newLocale) => {
-      if (config.loader?.type === "api") {
+      if (config.loader?.type === "remote") {
         setIsLoadingMessages(true);
-        const loadedMessages = await loadApiMessages({
-          ...config.loader,
+        const loadedMessages = await loadRemoteMessages({
+          rootDir: config.loader.rootDir,
+          remoteUrl: config.loader.remoteUrl,
+          remoteHeaders: config.loader.remoteHeaders,
           locale: newLocale,
           fallbackLocales: config.fallbackLocales[newLocale] || [],
           namespaces,
-          logger: { id: config.id }
+          extraOptions: {
+            cacheOptions: config.cache,
+            loggerOptions: { id: config.id }
+          }
         });
         const messages = mergeMessages(staticMessages, loadedMessages);
         setLoadedMessages(messages);
@@ -497,6 +486,7 @@ var useRefetchMessages = ({
   );
   return { refetchMessages };
 };
+var MessagesContext = React6__namespace.createContext(void 0);
 
 // src/adapters/next/contexts/messages/provider.tsx
 function MessagesProvider({
@@ -504,15 +494,15 @@ function MessagesProvider({
   children
 }) {
   const { config, pathname } = useConfig();
-  const [loadedMessages, setLoadedMessages] = React7__namespace.useState(null);
-  const [isLoadingMessages, setIsLoadingMessages] = React7__namespace.useState(false);
+  const [loadedMessages, setLoadedMessages] = React6__namespace.useState(null);
+  const [isLoadingMessages, setIsLoadingMessages] = React6__namespace.useState(false);
   const { refetchMessages } = useRefetchMessages({
     config,
     pathname,
     setLoadedMessages,
     setIsLoadingMessages
   });
-  const value = React7__namespace.useMemo(
+  const value = React6__namespace.useMemo(
     () => ({
       messages: loadedMessages || messages,
       isLoading: isLoadingMessages,
@@ -522,10 +512,10 @@ function MessagesProvider({
     }),
     [loadedMessages, messages, isLoadingMessages, refetchMessages]
   );
-  return /* @__PURE__ */ React7__namespace.createElement(MessagesContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6__namespace.createElement(MessagesContext.Provider, { value }, children);
 }
 function useMessages() {
-  const context = React7__namespace.useContext(MessagesContext);
+  const context = React6__namespace.useContext(MessagesContext);
   if (!context)
     throw new Error("useMessages must be used within a MessagesProvider");
   return context;
@@ -538,8 +528,8 @@ var useInitLazyLoad = ({
 }) => {
   const { refetchMessages } = useMessages();
   const lazyLoad = !!loaderOptions?.lazyLoad;
-  const isFirstLoadedRef = React7__namespace.useRef(false);
-  React7__namespace.useEffect(() => {
+  const isFirstLoadedRef = React6__namespace.useRef(false);
+  React6__namespace.useEffect(() => {
     if (lazyLoad && !isFirstLoadedRef.current) {
       void refetchMessages(currentLocale);
       isFirstLoadedRef.current = true;
@@ -585,7 +575,7 @@ var useInitLocaleCookie = ({
   config,
   locale
 }) => {
-  React7__namespace.useEffect(() => {
+  React6__namespace.useEffect(() => {
     if (typeof document === "undefined") return;
     const { cookie, routing } = config;
     const { firstVisit } = routing;
@@ -597,6 +587,7 @@ var useInitLocaleCookie = ({
     setLocaleCookieBrowser({ cookie, locale });
   }, []);
 };
+var LocaleContext = React6__namespace.createContext(void 0);
 
 // src/adapters/next/contexts/locale/utils/change-locale.ts
 var changeLocale = ({
@@ -610,15 +601,15 @@ var changeLocale = ({
   if (typeof document === "undefined") return;
   const loaderType = loaderOptions?.type;
   if (newLocale === currentLocale) return;
-  if (loaderType === "import") {
+  if (loaderType === "local") {
     console.warn(
-      `[Intor] You are using dynamic import to switch languages. Please make sure to use the wrapped <Link> component to trigger a page reload, ensuring that the translation data is dynamically updated.`
+      `[Intor] You are using dynamic local to switch languages. Please make sure to use the wrapped <Link> component to trigger a page reload, ensuring that the translation data is dynamically updated.`
     );
   }
   setLocale(newLocale);
   setLocaleCookieBrowser({ cookie, locale: newLocale });
   document.documentElement.lang = newLocale;
-  if (loaderType === "api" && refetchMessages) {
+  if (loaderType === "remote" && refetchMessages) {
     void refetchMessages(newLocale);
   }
 };
@@ -631,10 +622,10 @@ function LocaleProvider({
   const { config } = useConfig();
   const { refetchMessages } = useMessages();
   const { loader: loaderOptions, cookie } = config;
-  const [currentLocale, setCurrentLocale] = React7__namespace.useState(initialLocale);
+  const [currentLocale, setCurrentLocale] = React6__namespace.useState(initialLocale);
   useInitLazyLoad({ loaderOptions, currentLocale });
   useInitLocaleCookie({ config, locale: initialLocale });
-  const setLocale = React7__namespace.useCallback(
+  const setLocale = React6__namespace.useCallback(
     (newLocale) => {
       changeLocale({
         currentLocale,
@@ -647,43 +638,45 @@ function LocaleProvider({
     },
     [currentLocale, loaderOptions, cookie, refetchMessages]
   );
-  const value = React7__namespace.useMemo(
+  const value = React6__namespace.useMemo(
     () => ({
       locale: currentLocale,
       setLocale
     }),
     [currentLocale, setLocale]
   );
-  return /* @__PURE__ */ React7__namespace.createElement(LocaleContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6__namespace.createElement(LocaleContext.Provider, { value }, children);
 }
 function useLocale() {
-  const context = React7__namespace.useContext(LocaleContext);
+  const context = React6__namespace.useContext(LocaleContext);
   if (!context)
     throw new Error("useLocale must be used within a LocaleProvider");
   return context;
 }
-var TranslatorContext = React7__namespace.createContext(void 0);
-var TranslateHandlersContext = React7__namespace.createContext(void 0);
+var TranslateHandlersContext = React6__namespace.createContext(void 0);
+
+// src/adapters/next/contexts/translate-handlers/provider.tsx
 var TranslateHandlersProvider = ({
   children,
   handlers
 }) => {
   const value = handlers;
-  return /* @__PURE__ */ React7__namespace.createElement(TranslateHandlersContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6__namespace.createElement(TranslateHandlersContext.Provider, { value }, children);
 };
 function useTranslateHandlers() {
-  const context = React7__namespace.useContext(TranslateHandlersContext);
+  const context = React6__namespace.useContext(TranslateHandlersContext);
   return context;
 }
 var useInitLoadingState = (config) => {
   const lazyLoad = !!config.loader?.lazyLoad;
-  const [isCsr, setIsCsr] = React7__namespace.useState(false);
-  React7__namespace.useEffect(() => {
+  const [isCsr, setIsCsr] = React6__namespace.useState(false);
+  React6__namespace.useEffect(() => {
     setIsCsr(true);
   }, []);
   const isBeforeCSRLoading = lazyLoad && !isCsr;
   return isBeforeCSRLoading;
 };
+var TranslatorContext = React6__namespace.createContext(void 0);
 
 // src/adapters/next/contexts/translator/provider.tsx
 var EMPTY_OBJECT = Object.freeze({});
@@ -694,7 +687,7 @@ function TranslatorProvider({ children }) {
   const translatorHandlers = useTranslateHandlers();
   const { fallbackLocales, translator: translatorOptions } = config;
   const isBeforeCSRLoading = useInitLoadingState(config);
-  const value = React7__namespace.useMemo(() => {
+  const value = React6__namespace.useMemo(() => {
     const translator = new intorTranslator.Translator({
       messages: messages || EMPTY_OBJECT,
       locale,
@@ -715,10 +708,10 @@ function TranslatorProvider({ children }) {
     translatorOptions?.loadingMessage,
     translatorOptions?.placeholder
   ]);
-  return /* @__PURE__ */ React7__namespace.createElement(TranslatorContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6__namespace.createElement(TranslatorContext.Provider, { value }, children);
 }
 function useTranslator() {
-  const context = React7__namespace.useContext(TranslatorContext);
+  const context = React6__namespace.useContext(TranslatorContext);
   if (!context)
     throw new Error(
       "useTranslator must be used within IntorTranslatorProvider"
@@ -731,7 +724,7 @@ var IntorProvider = ({
   value: { config, pathname, initialLocale, messages },
   children
 }) => {
-  return /* @__PURE__ */ React7__namespace.createElement(ConfigProvider, { value: { config, pathname } }, /* @__PURE__ */ React7__namespace.createElement(MessagesProvider, { value: { messages } }, /* @__PURE__ */ React7__namespace.createElement(LocaleProvider, { value: { initialLocale } }, /* @__PURE__ */ React7__namespace.createElement(TranslatorProvider, null, children))));
+  return /* @__PURE__ */ React6__namespace.createElement(ConfigProvider, { value: { config, pathname } }, /* @__PURE__ */ React6__namespace.createElement(MessagesProvider, { value: { messages } }, /* @__PURE__ */ React6__namespace.createElement(LocaleProvider, { value: { initialLocale } }, /* @__PURE__ */ React6__namespace.createElement(TranslatorProvider, null, children))));
 };
 
 // src/adapters/next/hooks/use-translator/use-translator.ts
@@ -828,7 +821,7 @@ var shouldFullReload = ({
 }) => {
   const loader = config.loader;
   if (!loader || !loader.type) return false;
-  if (loader.type === "api" && !loader.fullReload) return false;
+  if (loader.type === "remote" && !loader.fullReload) return false;
   const { maybeLocale, isLocalePrefixed } = extractPathname({
     config,
     pathname: targetPathname
@@ -890,7 +883,7 @@ var Link = ({
     onClick?.(e);
     switchLocale({ href: formatted, locale });
   };
-  return /* @__PURE__ */ React7__namespace.createElement(NextLink__default.default, { href: resolvedHref, onClick: handleClick, ...props }, children);
+  return /* @__PURE__ */ React6__namespace.createElement(NextLink__default.default, { href: resolvedHref, onClick: handleClick, ...props }, children);
 };
 var useRouter = () => {
   const { push, replace, ...rest } = navigation.useRouter();

package/dist/next/index.d.cts

@@ -47,28 +47,28 @@ type RouteNamespaces = {
     [key: string]: string[];
     default: string[];
 };
-interface ApiHeaders {
+interface RemoteHeaders {
     authorization?: string;
     "x-api-key"?: string;
     [key: string]: string | undefined;
 }
 type BaseLoaderOptions = {
-    basePath?: string;
+    rootDir?: string;
     namespaces?: string[];
     routeNamespaces?: RouteNamespaces;
     concurrency?: number;
     lazyLoad?: boolean;
 };
-type ImportLoader = BaseLoaderOptions & {
-    type: "import";
+type LocalLoader = BaseLoaderOptions & {
+    type: "local";
 };
-type ApiLoader = BaseLoaderOptions & {
-    type: "api";
-    apiUrl: string;
-    apiHeaders?: ApiHeaders;
+type RemoteLoader = BaseLoaderOptions & {
+    type: "remote";
+    remoteUrl: string;
+    remoteHeaders?: RemoteHeaders;
     fullReload?: boolean;
 };
-type LoaderOptions = ImportLoader | ApiLoader;
+type LoaderOptions = LocalLoader | RemoteLoader;
 
 type LoggerOptions = {
     level?: Level;

package/dist/next/index.d.ts

@@ -47,28 +47,28 @@ type RouteNamespaces = {
     [key: string]: string[];
     default: string[];
 };
-interface ApiHeaders {
+interface RemoteHeaders {
     authorization?: string;
     "x-api-key"?: string;
     [key: string]: string | undefined;
 }
 type BaseLoaderOptions = {
-    basePath?: string;
+    rootDir?: string;
     namespaces?: string[];
     routeNamespaces?: RouteNamespaces;
     concurrency?: number;
     lazyLoad?: boolean;
 };
-type ImportLoader = BaseLoaderOptions & {
-    type: "import";
+type LocalLoader = BaseLoaderOptions & {
+    type: "local";
 };
-type ApiLoader = BaseLoaderOptions & {
-    type: "api";
-    apiUrl: string;
-    apiHeaders?: ApiHeaders;
+type RemoteLoader = BaseLoaderOptions & {
+    type: "remote";
+    remoteUrl: string;
+    remoteHeaders?: RemoteHeaders;
     fullReload?: boolean;
 };
-type LoaderOptions = ImportLoader | ApiLoader;
+type LoaderOptions = LocalLoader | RemoteLoader;
 
 type LoggerOptions = {
     level?: Level;