@route-forge/core 1.2.2 → 1.3.1

package/dist/index.js

@@ -465,6 +465,39 @@ async function resolveAdapter(opts) {
   return createBuiltinHttp(opts.forgeInterceptors);
 }
 
+// src/resolveRouteName.ts
+async function resolveRouteName(forge, level, prefix, suffix, separator = ".") {
+  if (!suffix) return prefix;
+  const joined = `${prefix}${separator}${suffix}`;
+  if (!suffix.startsWith(`${prefix}${separator}`)) return joined;
+  await forge.load(level);
+  if (forge.hasRoute(level, joined)) return joined;
+  if (forge.hasRoute(level, suffix)) return suffix;
+  throw new UnknownRouteError(joined, level);
+}
+function resolveRouteNameSync(forge, level, prefix, suffix, separator = ".") {
+  if (!suffix) return prefix;
+  const joined = `${prefix}${separator}${suffix}`;
+  if (!suffix.startsWith(`${prefix}${separator}`)) return joined;
+  if (forge.hasRoute(level, joined)) return joined;
+  if (forge.hasRoute(level, suffix)) return suffix;
+  throw new UnknownRouteError(joined, level);
+}
+
+// src/defineImmutableProps.ts
+function defineImmutableProps(target, props) {
+  for (const key of Object.keys(props)) {
+    const val = props[key];
+    Object.defineProperty(target, key, {
+      value: val !== null && typeof val === "object" ? Object.freeze(val) : val,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  return target;
+}
+
 // src/loading.ts
 var LoadingTracker = class {
   constructor() {
@@ -631,7 +664,6 @@ function createRouteForge(options) {
   const readyPromise = new Promise((resolve) => {
     resolveReady = resolve;
   });
-  const levelLoadedListeners = /* @__PURE__ */ new Map();
   const cacheTtl = cacheOpts.ttl ?? DEFAULT_CACHE_TTL;
   const cacheStorage = cacheOpts.storage ?? "memory";
   const cache = new RouteCache({ storage: cacheStorage, ttl: cacheTtl });
@@ -683,7 +715,7 @@ function createRouteForge(options) {
   function assertDiscoveryReady() {
     if (!autoDiscoveryCompleted && !explicitLevels?.length) {
       throw new ForgeError(
-        "Route data not available. Auto-discovery has not completed. Use onSummaryReady callback to mount app, or await forge.ready / forge.load(level) first.",
+        "Route data not available. Auto-discovery has not completed. Use forge.ready() or forge.use(level) first.",
         { code: "RF_FE_010" }
       );
     }
@@ -736,15 +768,11 @@ function createRouteForge(options) {
             routes[r.name] = { ...r, level: UNASSIGNED_LEVEL };
           }
           cache.set({ level: UNASSIGNED_LEVEL, routes, cache: null });
-          const listeners = levelLoadedListeners.get(level);
-          if (listeners) listeners.forEach((cb) => cb());
           return;
         }
         const resp = await fetchLevel(level);
         if ((invalidationGens.get(level) ?? 0) === gen) {
           cache.set(resp);
-          const listeners = levelLoadedListeners.get(level);
-          if (listeners) listeners.forEach((cb) => cb());
         }
       } finally {
         inflight.delete(level);
@@ -818,23 +846,40 @@ function createRouteForge(options) {
     }
     return void 0;
   }
-  async function api(level, name, params = {}) {
-    await autoDiscoveryPromise;
-    await load(level);
-    const meta = findRouteMeta(level, name);
-    if (!meta) {
-      throw new UnknownRouteError(name, level);
-    }
-    return doApiCall(meta, params);
+  function api(level, name, params = {}) {
+    let ctrl;
+    let abortedBeforeInit = false;
+    let abortReason;
+    const work = (async () => {
+      ctrl = new AbortController();
+      if (abortedBeforeInit) {
+        ctrl.abort(abortReason);
+      }
+      await autoDiscoveryPromise;
+      await load(level);
+      const meta = findRouteMeta(level, name);
+      if (!meta) {
+        throw new UnknownRouteError(name, level);
+      }
+      return doApiCall(meta, params, ctrl.signal);
+    })();
+    const request = work;
+    request.abort = () => {
+      if (ctrl) {
+        ctrl.abort();
+      } else {
+        abortedBeforeInit = true;
+      }
+    };
+    return request;
   }
-  async function doApiCall(meta, params) {
+  async function doApiCall(meta, params, signal) {
     const {
       pathParams,
       query,
       body,
       headers,
-      timeout: perCallTimeout,
-      signal
+      timeout: perCallTimeout
     } = resolveApiParams(params);
     if (signal?.aborted) {
       throw new RequestAbortedError(meta.name, meta.level, signal.reason);
@@ -878,7 +923,7 @@ function createRouteForge(options) {
         },
         (err) => {
           if (err instanceof ForgeError) throw err;
-          if (isAbortError2(err, finalConfig.signal)) {
+          if (isAbortError2(err, signal)) {
             throw new RequestAbortedError(meta.name, meta.level, err);
           }
           throw new NetworkError(
@@ -946,6 +991,7 @@ function createRouteForge(options) {
     return result;
   }
   void autoDiscoveryPromise.then(() => {
+    autoDiscoveryCompleted = true;
     options.onSummaryReady?.();
     if (effectiveEager.length > 0) {
       return Promise.all(effectiveEager.map((lvl) => load(lvl))).catch((e) => {
@@ -953,11 +999,74 @@ function createRouteForge(options) {
       });
     }
   }).then(() => {
-    autoDiscoveryCompleted = true;
-    resolveReady();
+    resolveReady(forgeInstance);
   }).catch(() => {
   });
-  return {
+  function ready(onFulfilled, onRejected) {
+    if (onFulfilled) {
+      const p = readyPromise.then(onFulfilled, onRejected);
+      return p.then(() => forgeInstance);
+    }
+    return readyPromise;
+  }
+  const forgeResolver = { load, hasRoute };
+  function createBoundForge(level, prefix) {
+    const levelLoadedPromise = load(level).catch(() => {
+    });
+    const apiFn = prefix ? (name, params) => resolveRouteName(forgeResolver, level, prefix, name).then(
+      (resolved) => api(level, resolved, params)
+    ) : (name, params) => api(level, name, params);
+    const callable = apiFn;
+    defineImmutableProps(callable, {
+      level,
+      ...prefix !== void 0 ? { prefix } : {},
+      api: apiFn,
+      route: prefix ? (name, params) => route(level, resolveRouteNameSync(forgeResolver, level, prefix, name), params) : (name, params) => route(level, name, params),
+      url: prefix ? (name, params) => route(level, resolveRouteNameSync(forgeResolver, level, prefix, name), params) : (name, params) => route(level, name, params),
+      hasRoute: (name) => hasRoute(level, name),
+      getRoutes: () => getRoutes(level),
+      load: () => load(level),
+      invalidate: () => invalidate(level),
+      isLoaded: () => isLoaded(level),
+      isLoading: () => loadingTracker.isLoading(),
+      onLoadingChange: (cb) => loadingTracker.subscribe(cb)
+    });
+    Object.defineProperty(callable, "levelLoaded", {
+      value: levelLoadedPromise,
+      writable: false,
+      enumerable: true,
+      configurable: true
+    });
+    return callable;
+  }
+  function boundOnLevelLoaded(bound, levelLoadedPromise, onFulfilled, onRejected) {
+    const p = levelLoadedPromise.then(() => bound);
+    if (onFulfilled) {
+      return p.then(onFulfilled, onRejected).then(() => bound);
+    }
+    return p;
+  }
+  function attachBoundMethods(bound, levelLoadedPromise, level) {
+    Object.defineProperty(bound, "onLevelLoaded", {
+      value: (onFulfilled, onRejected) => boundOnLevelLoaded(bound, levelLoadedPromise, onFulfilled, onRejected),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.defineProperty(bound, "useRoutePrefix", {
+      value: (prefix) => createBoundForgeWithMethods(level, prefix),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  function createBoundForgeWithMethods(level, prefix) {
+    const bound = createBoundForge(level, prefix);
+    const levelLoadedPromise = bound.levelLoaded;
+    attachBoundMethods(bound, levelLoadedPromise, level);
+    return bound;
+  }
+  const forgeInstance = {
     api,
     load,
     route,
@@ -972,15 +1081,13 @@ function createRouteForge(options) {
       request: requestInterceptors,
       response: responseInterceptors
     },
-    ready: readyPromise,
-    onLevelLoaded(level, cb) {
-      if (!levelLoadedListeners.has(level)) {
-        levelLoadedListeners.set(level, /* @__PURE__ */ new Set());
-      }
-      levelLoadedListeners.get(level).add(cb);
-      return () => levelLoadedListeners.get(level)?.delete(cb);
+    ready,
+    use(level, prefix) {
+      if (level === void 0) return forgeInstance;
+      return createBoundForgeWithMethods(level, prefix);
     }
   };
+  return forgeInstance;
 }
 function pickMethod(meta) {
   const m = meta.methods.find((x) => x.toUpperCase() !== "HEAD");
@@ -1004,7 +1111,6 @@ function resolveApiParams(input) {
     body: rawBody,
     headers: rawHeaders,
     timeout: perCallTimeout,
-    signal,
     ...flatRest
   } = input;
   const pathParams = explicitParams ? { ...explicitParams } : {};
@@ -1037,7 +1143,7 @@ function resolveApiParams(input) {
       pathParams.headers = rawHeaders;
     }
   }
-  return { pathParams, query, body, headers, timeout: perCallTimeout, signal };
+  return { pathParams, query, body, headers, timeout: perCallTimeout };
 }
 function isAbortError2(err, signal) {
   if (signal?.aborted) return true;
@@ -1048,25 +1154,6 @@ function isAbortError2(err, signal) {
   return false;
 }
 
-// src/resolveRouteName.ts
-async function resolveRouteName(forge, level, prefix, suffix, separator = ".") {
-  if (!suffix) return prefix;
-  const joined = `${prefix}${separator}${suffix}`;
-  if (!suffix.startsWith(`${prefix}${separator}`)) return joined;
-  await forge.load(level);
-  if (forge.hasRoute(level, joined)) return joined;
-  if (forge.hasRoute(level, suffix)) return suffix;
-  throw new UnknownRouteError(joined, level);
-}
-function resolveRouteNameSync(forge, level, prefix, suffix, separator = ".") {
-  if (!suffix) return prefix;
-  const joined = `${prefix}${separator}${suffix}`;
-  if (!suffix.startsWith(`${prefix}${separator}`)) return joined;
-  if (forge.hasRoute(level, joined)) return joined;
-  if (forge.hasRoute(level, suffix)) return suffix;
-  throw new UnknownRouteError(joined, level);
-}
-
 export { AdapterNotFoundError, ForgeError, HTTPError, InterceptorManagerImpl, InvalidInterceptorReturnError, LoadingTracker, MissingRouteParamError, NetworkError, RequestAbortedError, RouteCache, UnknownLevelError, UnknownRouteError, createInterceptorManager, createRouteForge, resolveRouteName, resolveRouteNameSync };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map