@route-forge/core 1.2.2 → 1.3.1

package/dist/route-forge.global.js

@@ -468,6 +468,39 @@ var RouteForge = (function (exports) {
     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() {
@@ -634,7 +667,6 @@ var RouteForge = (function (exports) {
     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 });
@@ -686,7 +718,7 @@ var RouteForge = (function (exports) {
     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" }
         );
       }
@@ -739,15 +771,11 @@ var RouteForge = (function (exports) {
               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);
@@ -821,23 +849,40 @@ var RouteForge = (function (exports) {
       }
       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);
@@ -881,7 +926,7 @@ var RouteForge = (function (exports) {
           },
           (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(
@@ -949,6 +994,7 @@ var RouteForge = (function (exports) {
       return result;
     }
     void autoDiscoveryPromise.then(() => {
+      autoDiscoveryCompleted = true;
       options.onSummaryReady?.();
       if (effectiveEager.length > 0) {
         return Promise.all(effectiveEager.map((lvl) => load(lvl))).catch((e) => {
@@ -956,11 +1002,74 @@ var RouteForge = (function (exports) {
         });
       }
     }).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,
@@ -975,15 +1084,13 @@ var RouteForge = (function (exports) {
         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");
@@ -1007,7 +1114,6 @@ var RouteForge = (function (exports) {
       body: rawBody,
       headers: rawHeaders,
       timeout: perCallTimeout,
-      signal,
       ...flatRest
     } = input;
     const pathParams = explicitParams ? { ...explicitParams } : {};
@@ -1040,7 +1146,7 @@ var RouteForge = (function (exports) {
         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;
@@ -1051,25 +1157,6 @@ var RouteForge = (function (exports) {
     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);
-  }
-
   exports.AdapterNotFoundError = AdapterNotFoundError;
   exports.ForgeError = ForgeError;
   exports.HTTPError = HTTPError;