@route-forge/core 1.2.2 → 1.3.0

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);
@@ -949,6 +977,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 +985,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 +1067,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");
@@ -1051,25 +1141,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;