loly 0.1.0

package/dist/client.js

@@ -0,0 +1,727 @@
+// src/client/router.ts
+import { bootIslands, mount, activateAsyncComponents } from "loly-jsx";
+
+// src/constants/server.ts
+var SERVER = {
+  DEFAULT_PORT: 3e3,
+  RSC_ENDPOINT: "/__loly/rsc",
+  IMAGE_ENDPOINT: "/_loly/image",
+  ASYNC_ENDPOINT: "/__loly/async",
+  APP_CONTAINER_ID: "app"
+};
+
+// src/constants/errors.ts
+var ERROR_MESSAGES = {
+  CONTEXT_NOT_INITIALIZED: "[loly-core] Framework context not initialized. Call setContext() first.",
+  APP_DIR_NOT_FOUND: (dir) => `[loly-core] src/app/ directory not found in ${dir}. Please ensure your project has a src/app/ directory.`,
+  ROUTE_NOT_FOUND: (pathname) => `Route not found: ${pathname}`,
+  PAGE_COMPONENT_NOT_FOUND: (path) => `[loly-core] Page component not found in ${path}`,
+  PAGE_COMPONENT_MUST_BE_FUNCTION: "[loly-core] Page component must be a function",
+  COMPONENT_NOT_FOUND: (route) => `Component not found for route: ${route}`,
+  APP_CONTAINER_NOT_FOUND: "[loly-core] App container not found (#app)",
+  CLIENT_BUILD_DIR_NOT_FOUND: (dir) => `[loly-core] Client build directory not found: ${dir}. Run 'loly build' first or the client scripts won't load.`,
+  ROUTES_MANIFEST_NOT_FOUND: (path) => `[loly-core] Routes manifest not found: ${path}. Run 'loly build' first.`,
+  DIRECTORY_NOT_FOUND: (dir) => `[loly-core] Directory not found: ${dir}`,
+  CLIENT_BUILD_FAILED: "Client build failed",
+  SERVER_BUILD_FAILED: "Server build failed",
+  FAILED_TO_LOAD_MODULE: (path) => `[loly-core] Failed to load module: ${path}`,
+  FAILED_TO_LOAD_ROUTE_COMPONENT: (path) => `[bootstrap] Failed to load component for route ${path}`,
+  FAILED_TO_LOAD_NESTED_LAYOUT: (path) => `[loly-core] Failed to load nested layout at ${path}`,
+  FAILED_TO_READ_CLIENT_MANIFEST: "[loly-core] Failed to read client manifest:",
+  FAILED_TO_PARSE_ISLAND_DATA: "[loly-core] Failed to parse island data:",
+  FATAL_BOOTSTRAP_ERROR: "[bootstrap] Fatal error during bootstrap:",
+  UNEXPECTED_ERROR: "[loly-core] Unexpected error:",
+  ERROR_STARTING_DEV_SERVER: "[loly-core] Error starting dev server:",
+  ERROR_STARTING_PROD_SERVER: "[loly-core] Error starting production server:",
+  ERROR_BUILDING_PROJECT: "[loly-core] Error building project:",
+  ERROR_HANDLING_REQUEST: "[loly-core] Error handling request:",
+  ERROR_RENDERING_PAGE: "[loly-core] Error rendering page:",
+  RSC_ENDPOINT_ERROR: "[loly-core] RSC endpoint error:"
+};
+
+// src/utils/path.ts
+function normalizePath(path) {
+  if (path === "/") return "/";
+  return path.replace(/\/$/, "") || "/";
+}
+function normalizeUrlPath(pathname) {
+  return normalizePath(pathname);
+}
+
+// src/utils/route-matcher.ts
+function matchRoutePattern(pattern, pathname) {
+  const normalizedPattern = normalizeUrlPath(pattern);
+  const normalizedPathname = normalizeUrlPath(pathname);
+  if (normalizedPattern === normalizedPathname) {
+    return { params: {} };
+  }
+  const patternParts = normalizedPattern.split("/").filter(Boolean);
+  const pathParts = normalizedPathname.split("/").filter(Boolean);
+  if (patternParts.length === 0 && pathParts.length === 0) {
+    return { params: {} };
+  }
+  const params = {};
+  let patternIdx = 0;
+  let pathIdx = 0;
+  while (patternIdx < patternParts.length && pathIdx < pathParts.length) {
+    const patternPart = patternParts[patternIdx];
+    const pathPart = pathParts[pathIdx];
+    if (patternPart.startsWith("*")) {
+      const paramName = patternPart.slice(1);
+      const remaining = pathParts.slice(pathIdx);
+      if (paramName) {
+        params[paramName] = remaining.join("/");
+      }
+      return { params };
+    }
+    if (patternPart.startsWith(":")) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = decodeURIComponent(pathPart);
+      patternIdx++;
+      pathIdx++;
+      continue;
+    }
+    if (patternPart === pathPart) {
+      patternIdx++;
+      pathIdx++;
+      continue;
+    }
+    return null;
+  }
+  if (patternIdx === patternParts.length && pathIdx === pathParts.length) {
+    return { params };
+  }
+  return null;
+}
+function extractRouteParams(pattern, pathname) {
+  const match = matchRoutePattern(pattern, pathname);
+  return match?.params || {};
+}
+function matchesRoute(pattern, pathname) {
+  if (pattern === pathname) return true;
+  const normalizedPattern = normalizeUrlPath(pattern);
+  const normalizedPathname = normalizeUrlPath(pathname);
+  if (normalizedPattern === normalizedPathname) return true;
+  const escaped = normalizedPattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(
+    "^" + escaped.replace(/:[^/]+/g, "([^/]+)") + "/?$"
+  );
+  return regex.test(normalizedPathname);
+}
+
+// src/client/router.ts
+var LRUCache = class {
+  constructor(maxSize = 10) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+function getInitialLocation() {
+  const { pathname, search, hash } = window.location;
+  return { pathname, search, hash };
+}
+function normalizePath2(path) {
+  const url = new URL(path, "http://localhost");
+  return {
+    pathname: normalizeUrlPath(url.pathname || "/"),
+    search: url.search,
+    hash: url.hash
+  };
+}
+async function fetchRSCPayload(pathname, search = "", options) {
+  const url = `${SERVER.RSC_ENDPOINT}?path=${encodeURIComponent(pathname)}${search ? `&search=${encodeURIComponent(search)}` : ""}`;
+  try {
+    const fetchOptions = {};
+    if (options?.priority) {
+      fetchOptions.priority = options.priority;
+    }
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+      if (response.status === 404) return null;
+      throw new Error(`Failed to fetch RSC: ${response.statusText}`);
+    }
+    const rscPayload = await response.json();
+    return {
+      html: rscPayload.html,
+      scripts: rscPayload.scripts || "",
+      styles: rscPayload.styles || "",
+      islandData: rscPayload.islandData || {}
+    };
+  } catch (error) {
+    return null;
+  }
+}
+async function loadComponent(route) {
+  try {
+    const module = await route.component();
+    const Component = module.default || module;
+    if (!Component) {
+      throw new Error(ERROR_MESSAGES.COMPONENT_NOT_FOUND(route.path));
+    }
+    return (props) => {
+      const safeProps = props && typeof props === "object" && !Array.isArray(props) ? props : { params: {}, searchParams: {} };
+      if (typeof Component === "function") {
+        return Component(safeProps);
+      }
+      return Component;
+    };
+  } catch (error) {
+    throw error;
+  }
+}
+function bootIslandsNow() {
+  bootIslands();
+}
+var globalRouter = null;
+function setGlobalRouter(router) {
+  globalRouter = router;
+}
+function getGlobalRouter() {
+  return globalRouter;
+}
+function navigate(to, options = {}) {
+  const router = getGlobalRouter();
+  if (router) {
+    router.navigate(to, options);
+  } else {
+    if (options.replace) {
+      window.history.replaceState({}, "", to);
+    } else {
+      window.history.pushState({}, "", to);
+    }
+    window.location.href = to;
+  }
+}
+var FrameworkRouter = class {
+  // Track links that have been pre-fetched
+  constructor(routes, appContainer) {
+    this.componentCache = /* @__PURE__ */ new Map();
+    this.loadedScripts = /* @__PURE__ */ new Set();
+    // Track loaded scripts
+    this.routeStyles = /* @__PURE__ */ new Map();
+    this.prefetchPromises = /* @__PURE__ */ new Map();
+    this.prefetchObserver = null;
+    this.MAX_CACHE_SIZE = 10;
+    this.invalidatedPaths = /* @__PURE__ */ new Set();
+    // Prepared for revalidatePath
+    this.prefetchedLinks = /* @__PURE__ */ new Set();
+    this.routes = routes;
+    this.appContainer = appContainer;
+    this.currentLocation = getInitialLocation();
+    this.rscPayloadCache = new LRUCache(this.MAX_CACHE_SIZE);
+    setGlobalRouter(this);
+    this.setupNavigation();
+    this.setupPopState();
+    this.setupPrefetch();
+  }
+  /**
+   * Check if pre-fetch should be performed based on connection
+   */
+  shouldPrefetch() {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (!connection) {
+      return true;
+    }
+    if (connection.effectiveType === "slow-2g" || connection.effectiveType === "2g") {
+      return false;
+    }
+    if (connection.saveData === true) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Generate cache key from pathname and search
+   */
+  getCacheKey(pathname, search = "") {
+    return `${normalizeUrlPath(pathname)}${search || ""}`;
+  }
+  /**
+   * Check if href is an internal link
+   */
+  isInternalLink(href) {
+    if (!href) return false;
+    if (href.startsWith("http") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Pre-fetch route data (RSC payload and JS component)
+   */
+  async prefetchRoute(pathname, search = "") {
+    if (!this.shouldPrefetch()) {
+      return null;
+    }
+    const key = this.getCacheKey(pathname, search);
+    if (this.invalidatedPaths.has(key)) {
+      return null;
+    }
+    const cached = this.rscPayloadCache.get(key);
+    if (cached) {
+      this.prefetchedLinks.add(key);
+      return cached;
+    }
+    if (this.prefetchPromises.has(key)) {
+      return this.prefetchPromises.get(key);
+    }
+    const promise = fetchRSCPayload(pathname, search, { priority: "low" }).then((payload) => {
+      if (payload) {
+        this.rscPayloadCache.set(key, payload);
+        this.prefetchedLinks.add(key);
+        const route = this.findRoute(pathname);
+        if (route) {
+          this.loadComponentCached(route).catch(() => {
+          });
+        }
+      }
+      return payload;
+    }).catch((error) => {
+      if (typeof console !== "undefined" && console.debug) {
+        console.debug("[loly-core] Pre-fetch failed:", error);
+      }
+      return null;
+    }).finally(() => {
+      this.prefetchPromises.delete(key);
+    });
+    this.prefetchPromises.set(key, promise);
+    return promise;
+  }
+  /**
+   * Navigate to a new path
+   */
+  navigate(to, options = {}) {
+    const next = normalizePath2(to);
+    if (options.replace) {
+      window.history.replaceState({}, "", to);
+    } else {
+      window.history.pushState({}, "", to);
+    }
+    this.currentLocation = next;
+    this.updateContent();
+    if (!next.hash) {
+      window.scrollTo({ top: 0 });
+    } else {
+      const el = document.getElementById(next.hash.slice(1));
+      if (el) {
+        el.scrollIntoView();
+      }
+    }
+  }
+  /**
+   * Update app content based on current location
+   */
+  async updateContent() {
+    const { pathname, search } = this.currentLocation;
+    const key = this.getCacheKey(pathname, search);
+    let rscPayload = this.rscPayloadCache.get(key) || null;
+    if (!rscPayload) {
+      rscPayload = await fetchRSCPayload(pathname, search);
+      if (rscPayload) {
+        this.rscPayloadCache.set(key, rscPayload);
+      }
+    }
+    this.prefetchPromises.delete(key);
+    if (rscPayload) {
+      const hasIslands = rscPayload.html.includes("data-loly-island");
+      if (hasIslands) {
+        const route2 = this.findRoute(pathname);
+        if (route2) {
+          try {
+            await this.loadComponentCached(route2);
+          } catch (err) {
+            console.warn(
+              "[loly-core] Failed to load route component for island registration:",
+              err
+            );
+          }
+        }
+      }
+      if (rscPayload.islandData && Object.keys(rscPayload.islandData).length > 0) {
+        if (!window.__LOLY_ISLAND_DATA__) {
+          window.__LOLY_ISLAND_DATA__ = {};
+        }
+        Object.assign(
+          window.__LOLY_ISLAND_DATA__,
+          rscPayload.islandData
+        );
+      }
+      const fragment = document.createDocumentFragment();
+      const tempDiv = document.createElement("div");
+      tempDiv.innerHTML = rscPayload.html;
+      while (tempDiv.firstChild) {
+        fragment.appendChild(tempDiv.firstChild);
+      }
+      this.appContainer.innerHTML = "";
+      this.appContainer.appendChild(fragment);
+      if (rscPayload.styles) {
+        this.injectStyles(pathname, rscPayload.styles);
+      }
+      if (rscPayload.scripts) {
+        await this.injectScripts(rscPayload.scripts);
+      }
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          bootIslandsNow();
+          this.observeNewLinks(this.appContainer);
+        });
+      });
+      return;
+    }
+    const route = this.findRoute(pathname);
+    if (route) {
+      try {
+        const Component = await this.loadComponentCached(route);
+        const searchParams = Object.fromEntries(
+          new URLSearchParams(search || "")
+        );
+        const params = extractRouteParams(route.path, pathname);
+        const result = Component({ params, searchParams });
+        this.appContainer.innerHTML = "";
+        mount(result, this.appContainer);
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            bootIslandsNow();
+            activateAsyncComponents(this.appContainer);
+            this.observeNewLinks(this.appContainer);
+          });
+        });
+      } catch (err) {
+        this.appContainer.innerHTML = "<div>Error loading route</div>";
+      }
+    } else {
+      this.appContainer.innerHTML = "<div>404 - Not Found</div>";
+    }
+  }
+  /**
+   * Inject styles for a route with deduplication
+   */
+  injectStyles(routePath, styles) {
+    const existing = this.routeStyles.get(routePath);
+    if (existing) {
+      existing.forEach((link) => {
+        if (!link.href.includes("globals.css")) {
+          link.remove();
+        }
+      });
+    }
+    if (!styles.trim()) return;
+    const tempDiv = document.createElement("div");
+    tempDiv.innerHTML = styles.trim();
+    const linkElements = [];
+    const links = tempDiv.querySelectorAll('link[rel="stylesheet"]');
+    links.forEach((link) => {
+      const href = link.getAttribute("href") || "";
+      if (href.includes("globals.css")) {
+        return;
+      }
+      const linkEl = document.createElement("link");
+      linkEl.rel = "stylesheet";
+      linkEl.href = href;
+      linkEl.setAttribute("data-route-styles", routePath);
+      const existingLink = document.querySelector(
+        `link[rel="stylesheet"][href="${href}"]`
+      );
+      if (!existingLink) {
+        document.head.appendChild(linkEl);
+        linkElements.push(linkEl);
+      }
+    });
+    if (linkElements.length > 0) {
+      this.routeStyles.set(routePath, linkElements);
+    }
+  }
+  /**
+   * Inject scripts with deduplication
+   */
+  async injectScripts(scripts) {
+    if (!scripts.trim()) return;
+    const tempDiv = document.createElement("div");
+    tempDiv.innerHTML = scripts;
+    const scriptTags = tempDiv.querySelectorAll("script");
+    const loadPromises = [];
+    scriptTags.forEach((script) => {
+      const src = script.getAttribute("src");
+      if (src) {
+        if (this.loadedScripts.has(src)) {
+          return;
+        }
+        this.loadedScripts.add(src);
+        const promise = new Promise((resolve, reject) => {
+          const newScript = document.createElement("script");
+          newScript.type = "module";
+          newScript.src = src;
+          newScript.onload = () => resolve();
+          newScript.onerror = () => {
+            this.loadedScripts.delete(src);
+            reject(new Error(`Failed to load script: ${src}`));
+          };
+          document.head.appendChild(newScript);
+        });
+        loadPromises.push(promise);
+      } else {
+        const inlineScript = document.createElement("script");
+        inlineScript.type = "module";
+        inlineScript.textContent = script.textContent || "";
+        document.head.appendChild(inlineScript);
+        setTimeout(() => inlineScript.remove(), 0);
+      }
+    });
+    await Promise.all(loadPromises);
+  }
+  /**
+   * Find matching route for pathname
+   */
+  findRoute(pathname) {
+    const exact = this.routes.find((r) => r.path === pathname);
+    if (exact) return exact;
+    for (const route of this.routes) {
+      if (matchesRoute(route.path, pathname)) {
+        return route;
+      }
+    }
+    return null;
+  }
+  /**
+   * Load component with caching
+   */
+  async loadComponentCached(route) {
+    if (this.componentCache.has(route.path)) {
+      return this.componentCache.get(route.path);
+    }
+    const Component = await loadComponent(route);
+    this.componentCache.set(route.path, Component);
+    return Component;
+  }
+  /**
+   * Setup navigation interception
+   */
+  setupNavigation() {
+    document.addEventListener("click", (e) => {
+      const target = e.target;
+      const link = target.closest("a");
+      if (!link) return;
+      const href = link.getAttribute("href");
+      if (!href) return;
+      if (href.startsWith("http") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+        return;
+      }
+      if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey || e.button !== 0) {
+        return;
+      }
+      if (link.target && link.target !== "_self") {
+        return;
+      }
+      if (e.defaultPrevented) {
+        return;
+      }
+      e.preventDefault();
+      this.navigate(href);
+    });
+  }
+  /**
+   * Setup popstate handler for browser back/forward
+   */
+  setupPopState() {
+    window.addEventListener("popstate", () => {
+      this.currentLocation = getInitialLocation();
+      this.updateContent();
+    });
+  }
+  /**
+   * Observe new links in container (called after DOM updates)
+   */
+  observeNewLinks(container) {
+    if (!this.prefetchObserver) return;
+    const links = container.querySelectorAll("a[href]");
+    links.forEach((link) => {
+      const href = link.getAttribute("href");
+      if (href && this.isInternalLink(href)) {
+        const { pathname, search } = normalizePath2(href);
+        const key = this.getCacheKey(pathname, search);
+        if (!this.rscPayloadCache.has(key) && !this.prefetchedLinks.has(key)) {
+          this.prefetchObserver.observe(link);
+        }
+      }
+    });
+  }
+  /**
+   * Setup pre-fetch with Intersection Observer and hover
+   */
+  setupPrefetch() {
+    this.prefetchObserver = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          if (entry.isIntersecting) {
+            const link = entry.target;
+            const href = link.getAttribute("href");
+            if (href && this.isInternalLink(href)) {
+              const { pathname, search } = normalizePath2(href);
+              const key = this.getCacheKey(pathname, search);
+              if (this.rscPayloadCache.has(key) || this.prefetchPromises.has(key)) {
+                this.prefetchObserver.unobserve(link);
+                this.prefetchedLinks.add(key);
+                return;
+              }
+              if (this.prefetchedLinks.has(key)) {
+                this.prefetchObserver.unobserve(link);
+                return;
+              }
+              this.prefetchedLinks.add(key);
+              this.prefetchRoute(pathname, search).then(() => {
+                this.prefetchObserver.unobserve(link);
+              });
+            }
+          }
+        });
+      },
+      { rootMargin: "200px" }
+    );
+    const allLinks = document.querySelectorAll("a[href]");
+    allLinks.forEach((link) => {
+      const href = link.getAttribute("href");
+      if (href && this.isInternalLink(href)) {
+        const { pathname, search } = normalizePath2(href);
+        const key = this.getCacheKey(pathname, search);
+        if (!this.rscPayloadCache.has(key) && !this.prefetchedLinks.has(key)) {
+          this.prefetchObserver.observe(link);
+        }
+      }
+    });
+    let hoverTimeout = null;
+    document.addEventListener(
+      "mouseenter",
+      (e) => {
+        const target = e.target;
+        if (!target || !(target instanceof Element)) {
+          return;
+        }
+        const link = target.closest("a");
+        if (link) {
+          const href = link.getAttribute("href");
+          if (href && this.isInternalLink(href)) {
+            const { pathname, search } = normalizePath2(href);
+            const key = this.getCacheKey(pathname, search);
+            if (this.rscPayloadCache.has(key) || this.prefetchedLinks.has(key)) {
+              return;
+            }
+            if (hoverTimeout) {
+              clearTimeout(hoverTimeout);
+            }
+            hoverTimeout = setTimeout(() => {
+              if (!this.rscPayloadCache.has(key) && !this.prefetchedLinks.has(key)) {
+                this.prefetchedLinks.add(key);
+                this.prefetchRoute(pathname, search);
+              }
+            }, 100);
+          }
+        }
+      },
+      true
+      // Capture phase
+    );
+  }
+  /**
+   * Initialize router (call after initial page load)
+   */
+  init() {
+    const self = this;
+    const initIslands = () => {
+      setTimeout(() => {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            bootIslandsNow();
+            activateAsyncComponents(self.appContainer);
+            self.observeNewLinks(self.appContainer);
+          });
+        });
+      }, 0);
+    };
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", initIslands, { once: true });
+    } else {
+      initIslands();
+    }
+  }
+  /**
+   * Invalidate cache for a specific path (prepared for future revalidatePath implementation)
+   * TODO: Implementar invalidación completa cuando se implemente revalidatePath
+   */
+  revalidatePath(pathname, search = "") {
+    const key = this.getCacheKey(pathname, search);
+    this.invalidatedPaths.add(key);
+    this.rscPayloadCache.delete(key);
+    this.prefetchPromises.delete(key);
+    this.prefetchedLinks.delete(key);
+  }
+};
+
+// src/client/bootstrap.tsx
+async function loadComponent2(route) {
+  try {
+    const module = await route.component();
+    const Component = module.default || module;
+    if (!Component) {
+      throw new Error(ERROR_MESSAGES.COMPONENT_NOT_FOUND(route.path));
+    }
+    return Component;
+  } catch (error) {
+    console.error(ERROR_MESSAGES.FAILED_TO_LOAD_ROUTE_COMPONENT(route.path), error);
+    throw error;
+  }
+}
+function bootstrapClient(options) {
+  const { routes } = options;
+  const appContainer = document.getElementById(SERVER.APP_CONTAINER_ID);
+  if (!appContainer) {
+    console.error(ERROR_MESSAGES.APP_CONTAINER_NOT_FOUND);
+    return;
+  }
+  const currentPath = window.location.pathname;
+  const currentRoute = routes.find((route) => matchesRoute(route.path, currentPath));
+  if (currentRoute) {
+    loadComponent2(currentRoute).then(() => {
+    }).catch(() => {
+    });
+  }
+  const router = new FrameworkRouter(routes, appContainer);
+  router.init();
+}
+export {
+  bootstrapClient,
+  getGlobalRouter,
+  navigate
+};
+//# sourceMappingURL=client.js.map