@tileflow/vite 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/index.js

@@ -1,11 +1,18 @@
 // src/index.ts
+import { resolve } from "path";
 import {
   createTileflowBuildArtifacts,
   createTileflowDevRequestHandler,
+  createTileflowNodeRequest,
   defaultTileflowConfigPath,
-  normalizeTileflowBasePath
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  getTileflowWatchPaths,
+  isTileflowRequestUrl,
+  joinTileflowPublicUrl,
+  normalizeTileflowBasePath,
+  writeTileflowNodeResponse
 } from "@tileflow/dev";
-import { resolve } from "path";
 function tileflow(options = {}) {
   const basePath = normalizeTileflowBasePath(options.base ?? "/tileflow");
   const configPath = options.config ?? defaultTileflowConfigPath;
@@ -18,6 +25,7 @@ function tileflow(options = {}) {
     configureServer(server) {
       const root = server.config.root;
       const configFile = resolve(root, configPath);
+      const watchedIconPaths = /* @__PURE__ */ new Set();
       const handler = createTileflowDevRequestHandler({
         basePath,
         config: configPath,
@@ -28,21 +36,47 @@ function tileflow(options = {}) {
         },
         tileBaseUrl: options.tileBaseUrl
       });
-      server.watcher.add(configFile);
-      server.watcher.on("change", (file) => {
+      const refreshWatchedIconPaths = async () => {
+        try {
+          const watchPaths = await getTileflowWatchPaths({
+            config: configPath,
+            cwd: root
+          });
+          for (const watchPath of watchPaths) {
+            if (!watchedIconPaths.has(watchPath)) {
+              server.watcher.add(watchPath);
+              watchedIconPaths.add(watchPath);
+            }
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown Tileflow error";
+          server.config.logger.warn(`[tileflow] Unable to watch icon paths: ${message}`);
+        }
+      };
+      const reloadIfTileflowInput = (file) => {
         if (file === configFile) {
+          void refreshWatchedIconPaths();
           server.ws.send({ type: "full-reload" });
+          return;
         }
-      });
+        if (isWatchedIconPath(file, watchedIconPaths)) {
+          server.ws.send({ type: "full-reload" });
+        }
+      };
+      server.watcher.add(configFile);
+      void refreshWatchedIconPaths();
+      server.watcher.on("add", reloadIfTileflowInput);
+      server.watcher.on("change", reloadIfTileflowInput);
+      server.watcher.on("unlink", reloadIfTileflowInput);
       server.middlewares.use(async (request, response, next) => {
-        if (!isTileflowRequest(request.url, basePath)) {
+        if (!isTileflowRequestUrl(request.url, basePath)) {
           next();
           return;
         }
         try {
-          const tileflowRequest = toWebRequest(request);
+          const tileflowRequest = createTileflowNodeRequest(request);
           const tileflowResponse = await handler(tileflowRequest);
-          await writeNodeResponse(response, tileflowResponse);
+          await writeTileflowNodeResponse(response, tileflowResponse);
         } catch (error) {
           next(error);
         }
@@ -57,71 +91,50 @@ function tileflow(options = {}) {
         return;
       }
       const artifacts = await createTileflowBuildArtifacts({
+        assetBaseUrl: joinTileflowPublicUrl(config.base, basePath),
         config: configPath,
         cwd: config.root,
-        styleBaseUrl: joinPublicUrl(config.base, basePath),
+        styleBaseUrl: joinTileflowPublicUrl(config.base, basePath),
         tileBaseUrl: options.tileBaseUrl
       });
-      const assetBase = assetBasePath(basePath);
+      const assetBase = getTileflowAssetBasePath(basePath);
       this.emitFile({
-        fileName: assetFileName(assetBase, "manifest.json"),
+        fileName: getTileflowAssetFileName(assetBase, "manifest.json"),
         source: `${JSON.stringify(artifacts.manifest, null, 2)}
 `,
         type: "asset"
       });
       for (const [mapName, style] of Object.entries(artifacts.styles)) {
         this.emitFile({
-          fileName: assetFileName(assetBase, `styles/${mapName}.json`),
+          fileName: getTileflowAssetFileName(assetBase, `styles/${mapName}.json`),
           source: `${JSON.stringify(style, null, 2)}
 `,
           type: "asset"
         });
       }
+      for (const asset of artifacts.assets) {
+        this.emitFile({
+          fileName: getTileflowAssetFileName(assetBase, asset.fileName),
+          source: asset.source,
+          type: "asset"
+        });
+      }
     }
   };
 }
 var index_default = tileflow;
-function isTileflowRequest(url, basePath) {
-  const pathname = (url ?? "/").split("?")[0] ?? "/";
-  if (!basePath) {
-    return pathname === "/manifest.json" || pathname === "/style.json" || pathname === "/" || pathname.startsWith("/styles/");
-  }
-  return pathname === basePath || pathname.startsWith(`${basePath}/`);
-}
-function toWebRequest(request) {
-  const protocol = getHeader(request, "x-forwarded-proto") ?? "http";
-  const host = getHeader(request, "host") ?? "localhost";
-  return new Request(`${protocol}://${host}${request.url ?? "/"}`, {
-    method: request.method
-  });
-}
-function getHeader(request, name) {
-  const value = request.headers[name];
-  return Array.isArray(value) ? value[0] : value;
-}
-async function writeNodeResponse(response, tileflowResponse) {
-  response.statusCode = tileflowResponse.status;
-  tileflowResponse.headers.forEach((value, key) => {
-    response.setHeader(key, value);
-  });
-  response.end(Buffer.from(await tileflowResponse.arrayBuffer()));
-}
-function joinPublicUrl(viteBase, basePath) {
-  const trimmedBase = viteBase.replace(/\/+$/g, "");
-  const trimmedPath = basePath.replace(/^\/+|\/+$/g, "");
-  if (!trimmedPath) {
-    return trimmedBase || "";
-  }
-  if (!trimmedBase || trimmedBase === ".") {
-    return `/${trimmedPath}`;
+function isWatchedIconPath(file, watchedIconPaths) {
+  const normalizedFile = normalizePath(file);
+  for (const watchPath of watchedIconPaths) {
+    const normalizedWatchPath = normalizePath(watchPath);
+    if (normalizedFile === normalizedWatchPath || normalizedFile.startsWith(`${normalizedWatchPath}/`)) {
+      return true;
+    }
   }
-  return `${trimmedBase}/${trimmedPath}`;
-}
-function assetBasePath(basePath) {
-  return basePath.replace(/^\/+|\/+$/g, "");
+  return false;
 }
-function assetFileName(basePath, fileName) {
-  return basePath ? `${basePath}/${fileName}` : fileName;
+function normalizePath(value) {
+  return value.replace(/\\/g, "/");
 }
 export {
   index_default as default,

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@tileflow/vite",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.10",
   "description": "Vite plugin for Tileflow map style development and static artifacts.",
   "type": "module",
+  "sideEffects": false,
   "homepage": "https://tileflow.dev",
   "repository": {
     "type": "git",
@@ -35,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@tileflow/dev": "0.1.0-alpha.1"
+    "@tileflow/dev": "0.1.0-alpha.10"
   },
   "peerDependencies": {
     "vite": ">=5"