@tileflow/core 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/index.js

@@ -6821,6 +6821,250 @@ function createTileflowSessionId() {
   }
   return `ses_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
 }
+function createTileflowSessionController(input) {
+  const fetchGrant = input.fetch ?? globalThis.fetch;
+  const grantTimeoutMs = validateSessionGrantTimeout(input.grantTimeoutMs);
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const sessionIdFactory = input.sessionIdFactory ?? createTileflowSessionId;
+  const createSession = (startedAt) => ({
+    binding: null,
+    grant: null,
+    grantPromise: null,
+    pendingGrantRequests: 0,
+    requestCount: 0,
+    sessionId: sessionIdFactory(),
+    startedAt
+  });
+  let activeSession = createSession(now().getTime());
+  async function resolveGrant(session, analytics, at) {
+    if (session.grant && session.grant.expiresAt - at > 3e4) {
+      return { grant: session.grant, session };
+    }
+    session.pendingGrantRequests += 1;
+    try {
+      if (!session.grantPromise) {
+        const pending = (async () => {
+          try {
+            const nextGrant = await requestSessionGrant({
+              analytics,
+              at,
+              fetchGrant,
+              timeoutMs: grantTimeoutMs,
+              sessionId: session.sessionId,
+              source: input.source
+            });
+            session.grant = nextGrant;
+            return { grant: nextGrant, session };
+          } catch (error) {
+            if (!(error instanceof TileflowSessionRestartError)) throw error;
+            const replacement = createSession(at);
+            replacement.binding = session.binding;
+            replacement.requestCount = session.pendingGrantRequests;
+            if (activeSession === session) activeSession = replacement;
+            const replacementPending = requestSessionGrant({
+              analytics,
+              at,
+              fetchGrant,
+              timeoutMs: grantTimeoutMs,
+              sessionId: replacement.sessionId,
+              source: input.source
+            }).then((nextGrant) => {
+              replacement.grant = nextGrant;
+              return { grant: nextGrant, session: replacement };
+            });
+            replacement.grantPromise = replacementPending;
+            try {
+              return await replacementPending;
+            } finally {
+              if (replacement.grantPromise === replacementPending) {
+                replacement.grantPromise = null;
+              }
+            }
+          } finally {
+            session.grantPromise = null;
+          }
+        })();
+        session.grantPromise = pending;
+      }
+      return await session.grantPromise;
+    } finally {
+      session.pendingGrantRequests -= 1;
+    }
+  }
+  return {
+    get sessionId() {
+      return activeSession.sessionId;
+    },
+    async resolveRequestUrl(url, analytics) {
+      if (!analytics || !analytics.mapId) return void 0;
+      const at = now().getTime();
+      if (at - activeSession.startedAt >= 6 * 60 * 60 * 1e3 || activeSession.requestCount >= 1e4) {
+        activeSession = createSession(at);
+      }
+      const apiOrigin = originOf(getTileflowAnalyticsApiUrl(analytics));
+      const binding = JSON.stringify([getTileflowAnalyticsApiUrl(analytics), analytics.mapId]);
+      let session = activeSession;
+      const grantedOrigins = session.binding === binding ? session.grant?.resourceOrigins : void 0;
+      if (!isEligibleResource(url, analytics.mapId, apiOrigin, grantedOrigins)) {
+        return void 0;
+      }
+      if (session.binding !== null && session.binding !== binding) {
+        session = createSession(at);
+        activeSession = session;
+      }
+      session.binding = binding;
+      session.requestCount += 1;
+      const resolved = await resolveGrant(session, analytics, at);
+      const nextUrl = new URL(url);
+      nextUrl.searchParams.set("session", resolved.session.sessionId);
+      nextUrl.searchParams.set("map", analytics.mapId);
+      if (analytics.styleId) nextUrl.searchParams.set("styleId", analytics.styleId);
+      if (resolved.grant.token) nextUrl.searchParams.set("grant", resolved.grant.token);
+      return nextUrl.toString();
+    }
+  };
+}
+async function requestSessionGrant(input) {
+  return runWithinSessionGrantTimeout(input.timeoutMs, async (signal) => {
+    const apiUrl = getTileflowAnalyticsApiUrl(input.analytics);
+    const response = await input.fetchGrant(`${apiUrl}/v1/sessions/start`, {
+      body: JSON.stringify({
+        mapId: input.analytics.mapId,
+        sdkVersion: input.analytics.sdkVersion,
+        sessionId: input.sessionId,
+        source: input.analytics.source ?? input.source,
+        styleId: input.analytics.styleId
+      }),
+      credentials: "omit",
+      headers: { "Content-Type": "application/json" },
+      method: "POST",
+      signal
+    });
+    throwIfSessionGrantAborted(signal);
+    const body = await response.json().catch(() => null);
+    throwIfSessionGrantAborted(signal);
+    if (response.status === 409 && isRecord6(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
+      throw new TileflowSessionRestartError();
+    }
+    if (!response.ok) {
+      throw new Error(`Tileflow session grant failed: ${response.status}`);
+    }
+    const parsed = parseSessionGrantResponse(body, input.sessionId);
+    if (!parsed) {
+      throw new Error("Tileflow session grant response was invalid.");
+    }
+    const expiresAt = parsed.grant ? Date.parse(parsed.expiresAt) : input.at + 6e4;
+    if (response.status === 201 && (!parsed.grant || !parsed.expiresAt) || parsed.grant && (!Number.isFinite(expiresAt) || expiresAt <= input.at)) {
+      throw new Error("Tileflow session grant response was invalid.");
+    }
+    return {
+      expiresAt,
+      resourceOrigins: new Set(
+        [originOf(apiUrl), ...(parsed.resourceOrigins ?? []).map(originOf)].filter(
+          (value) => Boolean(value)
+        )
+      ),
+      token: parsed.grant ?? null
+    };
+  });
+}
+function validateSessionGrantTimeout(value) {
+  const resolved = value ?? 1e4;
+  if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > 12e4) {
+    throw new Error("Tileflow session grantTimeoutMs must be an integer from 1 to 120000");
+  }
+  return resolved;
+}
+async function runWithinSessionGrantTimeout(timeoutMs, operation) {
+  const controller = new AbortController();
+  const timeoutError = new Error(`Tileflow session grant timed out after ${timeoutMs}ms`);
+  const timeout = setTimeout(() => controller.abort(timeoutError), timeoutMs);
+  try {
+    return await raceSessionGrantWithAbort(operation(controller.signal), controller.signal);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function raceSessionGrantWithAbort(operation, signal) {
+  if (signal.aborted) return Promise.reject(sessionGrantAbortReason(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(sessionGrantAbortReason(signal));
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+function throwIfSessionGrantAborted(signal) {
+  if (signal.aborted) throw sessionGrantAbortReason(signal);
+}
+function sessionGrantAbortReason(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  const error = new Error("Tileflow session grant was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function parseSessionGrantResponse(value, expectedSessionId) {
+  if (!isRecord6(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
+  if (value.usageMode !== void 0 && value.usageMode !== "session") return null;
+  if (value.billingEnabled !== void 0 && value.billingEnabled !== false) return null;
+  if (value.disposition !== void 0 && value.disposition !== "ordinary" && value.disposition !== "unbilled_fail_open") {
+    return null;
+  }
+  if (value.meterMode !== void 0 && value.meterMode !== "disabled" && value.meterMode !== "shadow" && value.meterMode !== "enforced") {
+    return null;
+  }
+  if (value.grant !== void 0 && (typeof value.grant !== "string" || value.grant.length === 0 || value.grant.length > 8192)) {
+    return null;
+  }
+  if (value.expiresAt !== void 0 && typeof value.expiresAt !== "string") return null;
+  if (value.grant !== void 0 && value.expiresAt === void 0) return null;
+  if (value.resourceOrigins !== void 0 && (!Array.isArray(value.resourceOrigins) || value.resourceOrigins.length > 32 || value.resourceOrigins.some((origin) => !originOf(origin)))) {
+    return null;
+  }
+  return value;
+}
+function isRecord6(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+var TileflowSessionRestartError = class extends Error {
+  constructor() {
+    super("Tileflow session must restart");
+    this.name = "TileflowSessionRestartError";
+  }
+};
+function isEligibleResource(value, mapId, apiOrigin, grantedOrigins) {
+  try {
+    const url = new URL(value);
+    if (url.username || url.password) return false;
+    const originAllowed = url.origin === apiOrigin || grantedOrigins?.has(url.origin) || apiOrigin === "https://api.tileflow.dev" && url.origin === "https://cdn.tileflow.dev";
+    if (!originAllowed) return false;
+    return url.pathname === `/maps/${encodeURIComponent(mapId)}/style.json` || url.pathname.startsWith("/tiles/") || url.pathname.startsWith("/v1/tiles/") || url.pathname.startsWith("/fonts/") || url.pathname.startsWith("/sprites/");
+  } catch {
+    return false;
+  }
+}
+function originOf(value) {
+  if (typeof value !== "string") return null;
+  try {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) return null;
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
 function resolveTileflowAnalyticsRequestUrl(url, analytics, sessionId) {
   if (!analytics || analytics.enabled === false) {
     return void 0;
@@ -6843,7 +7087,7 @@ function startTileflowSession(analytics, input) {
   if (!analytics || analytics.enabled === false || !input.mapId || typeof navigator === "undefined") {
     return;
   }
-  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/start`;
+  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/analytics`;
   const payload = JSON.stringify({
     mapId: input.mapId,
     metadata: analytics.metadata,
@@ -6866,7 +7110,7 @@ function startTileflowSession(analytics, input) {
     },
     keepalive: true,
     method: "POST"
-  });
+  }).catch(() => void 0);
 }
 function getTileflowAnalyticsApiUrl(analytics) {
   if (analytics.apiUrl) {
@@ -6883,9 +7127,6 @@ function getTileflowAnalyticsApiUrl(analytics) {
   return "https://api.tileflow.dev";
 }
 function mergeTileflowAnalytics(userAnalytics, runtimeAnalytics) {
-  if (userAnalytics?.enabled === false) {
-    return userAnalytics;
-  }
   if (!userAnalytics && !runtimeAnalytics?.mapId) {
     return void 0;
   }
@@ -6994,7 +7235,7 @@ function normalizeTileflowStaticImageSize(input) {
 function inferTileflowAnalyticsFromStyleUrl(styleUrl) {
   try {
     const url = new URL(styleUrl, getTileflowLocationOrigin());
-    const match = url.pathname.match(/\/(?:v1\/)?maps\/([^/]+)\/style\.json$/);
+    const match = url.pathname.match(/^\/maps\/([^/]+)\/style\.json$/);
     if (!match?.[1]) {
       return void 0;
     }
@@ -7037,6 +7278,7 @@ export {
   createManifest,
   createStyle,
   createStyleFromProject,
+  createTileflowSessionController,
   createTileflowSessionId,
   defaultTileflowManifestUrl,
   defaultTileflowStyleBaseUrl,