@tileflow/vite 0.1.0-alpha.25 → 0.1.0-alpha.27

package/README.md

@@ -52,21 +52,29 @@ component can use `source={{map: 'madrid'}}`; it reads `/tileflow/manifest.json`
 a Tileflow map, not a renderer or direct style. Do not also run a CLI build that overwrites the same
 delivery manifest. Config loading executes trusted imports and is not a sandbox.
 
-## Configure the worker
+## MapLibre's worker
 
-In a React application's client entry, before mounting an interactive map:
+`tileflow()` also gives interactive maps MapLibre's worker, in development and production builds.
+Each client module that imports `@tileflow/dom`, `@tileflow/react`, `@tileflow/vue`,
+`@tileflow/svelte` or `@tileflow/elements` imports the worker of the MapLibre that package renders
+with, the way Vite delivers workers, so the application needs no worker setup. Import
+`maplibre-gl/dist/maplibre-gl.css` in the client.
+
+An application that renders maps without `tileflow()`, for example from a CLI build or a hosted
+manifest, adds only the worker:
+
+<!-- docs:check -->
 
 ```ts
-import workerUrl from 'maplibre-gl/dist/maplibre-gl-worker.mjs?worker&url';
-import {configureTileflowMapLibre} from '@tileflow/react';
+import {defineConfig} from 'vite';
+import {tileflowMapLibreWorker} from '@tileflow/vite';
 
-configureTileflowMapLibre({workerUrl});
+export default defineConfig({plugins: [tileflowMapLibreWorker()]});
 ```
 
-Vue and Svelte import the configuration function from their own adapter. This URL import is
-Vite-specific. Keep the worker and main module from the same installed MapLibre version, and import
-`maplibre-gl/dist/maplibre-gl.css` in the client. The browser needs the emitted worker closure, not
-a CDN worker from another version.
+An explicit `configureTileflowMapLibre({workerUrl})` call still decides, and MapLibre's worker is
+set once. Once a map has started with the plugin's worker, configuring a different one throws. To
+deliver the worker yourself, turn the plugin's off with `tileflow({mapLibreWorker: false})`.
 
 ## Serve under a subpath
 

package/dist/index.d.ts

@@ -13,8 +13,27 @@ type TileflowVitePluginOptions = {
      * transport used to hydrate exact locked pins. No build resolves a catalog head.
      */
     icons?: TileflowIconResolutionOptions;
+    /**
+     * Give interactive maps the application's own MapLibre worker, in development and production.
+     * On by default; `false` leaves the worker to an explicit `configureTileflowMapLibre` call.
+     */
+    mapLibreWorker?: boolean;
     overwriteHostedManifest?: boolean;
 };
-declare function tileflow(options?: TileflowVitePluginOptions): Plugin;
+/**
+ * Prepare Tileflow maps for a Vite application and, unless `mapLibreWorker` is `false`, give its
+ * interactive maps MapLibre's worker.
+ */
+declare function tileflow(options?: TileflowVitePluginOptions): Plugin[];
+/**
+ * Give interactive Tileflow maps the application's own MapLibre worker, for an application that
+ * renders maps without `tileflow()`, such as one that only shows hosted maps.
+ *
+ * Every client module that imports `@tileflow/dom`, `@tileflow/react`, `@tileflow/vue`,
+ * `@tileflow/svelte` or `@tileflow/elements` also imports the worker of the MapLibre that package
+ * renders with, the way Vite delivers a worker (`?worker&url`), and offers it as the default. An
+ * explicit `configureTileflowMapLibre` call still decides, and the worker is configured once.
+ */
+declare function tileflowMapLibreWorker(): Plugin;
 
-export { type TileflowVitePluginOptions, tileflow as default, tileflow };
+export { type TileflowVitePluginOptions, tileflow as default, tileflow, tileflowMapLibreWorker };

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/index.ts
-import { resolve } from "path";
+import { existsSync, realpathSync } from "fs";
+import { dirname, isAbsolute, join, resolve } from "path";
 import {
   assertNoLocalTilesetsForProduction,
   assertTileflowSelfHostedManifestTarget,
@@ -21,6 +22,73 @@ import {
   writeTileflowNodeResponse
 } from "@tileflow/dev/server";
 function tileflow(options = {}) {
+  const plugin = tileflowArtifacts(options);
+  return options.mapLibreWorker === false ? [plugin] : [plugin, tileflowMapLibreWorker()];
+}
+function tileflowMapLibreWorker() {
+  const workerPaths = /* @__PURE__ */ new Map();
+  let root = process.cwd();
+  let warned = false;
+  return {
+    name: "tileflow:maplibre-worker",
+    // After framework plugins have turned components into JavaScript, before Vite rewrites imports.
+    enforce: "post",
+    configResolved(config) {
+      root = config.root;
+    },
+    transform(code, id, transformOptions) {
+      if (transformOptions?.ssr || !isApplicationModule(id)) return null;
+      const packageName = tileflowBrowserPackageImport.exec(code)?.[2];
+      if (packageName === void 0) return null;
+      const importerDirectory = isAbsolute(id) ? dirname(stripQuery(id)) : root;
+      const cacheKey = `${importerDirectory}\0${packageName}`;
+      if (!workerPaths.has(cacheKey)) {
+        workerPaths.set(
+          cacheKey,
+          findMapLibreWorker(`@tileflow/${packageName}`, importerDirectory)
+        );
+      }
+      const workerPath = workerPaths.get(cacheKey);
+      if (workerPath === void 0) {
+        if (!warned) {
+          warned = true;
+          this.warn(
+            `Unable to find the MapLibre worker of @tileflow/${packageName} from ${id}; configure it with configureTileflowMapLibre.`
+          );
+        }
+        return null;
+      }
+      const prelude = `import __tileflowMapLibreWorkerUrl from ${JSON.stringify(`${normalizePath(workerPath)}?worker&url`)};globalThis[Symbol.for('tileflow.maplibre.workerUrl')] ??= __tileflowMapLibreWorkerUrl;`;
+      return { code: `${prelude}${code}`, map: null };
+    }
+  };
+}
+var tileflowBrowserPackageImport = /(?:\bfrom|\bimport)\s*\(?\s*(['"])@tileflow\/(dom|elements|react|svelte|vue)(?:\/[^'"]*)?\1/u;
+function isApplicationModule(id) {
+  if (id.startsWith("\0") || /[\\/]node_modules[\\/]/u.test(id)) return false;
+  return !/[?&](?:worker|sharedworker|worker_file|url|raw|inline)\b/u.test(id);
+}
+function findMapLibreWorker(packageName, fromDirectory) {
+  const packageDirectory = findPackageDirectory(packageName, fromDirectory);
+  if (packageDirectory === void 0) return void 0;
+  const domDirectory = packageName === "@tileflow/dom" ? packageDirectory : findPackageDirectory("@tileflow/dom", packageDirectory) ?? packageDirectory;
+  const mapLibreDirectory = findPackageDirectory("maplibre-gl", domDirectory);
+  if (mapLibreDirectory === void 0) return void 0;
+  const workerPath = join(mapLibreDirectory, "dist", "maplibre-gl-worker.mjs");
+  return existsSync(workerPath) ? workerPath : void 0;
+}
+function findPackageDirectory(packageName, fromDirectory) {
+  for (let directory = fromDirectory; ; directory = dirname(directory)) {
+    const candidate = join(directory, "node_modules", packageName);
+    if (existsSync(join(candidate, "package.json"))) return realpathSync(candidate);
+    if (dirname(directory) === directory) return void 0;
+  }
+}
+function stripQuery(id) {
+  const queryIndex = id.indexOf("?");
+  return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
+function tileflowArtifacts(options) {
   const basePath = normalizeTileflowBasePath(options.base ?? "/tileflow");
   const configPath = options.config ?? defaultTileflowConfigPath;
   let viteConfig = null;
@@ -187,5 +255,6 @@ function getViteDevBasePaths(publicBase, basePath) {
 }
 export {
   index_default as default,
-  tileflow
+  tileflow,
+  tileflowMapLibreWorker
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tileflow/vite",
-  "version": "0.1.0-alpha.25",
+  "version": "0.1.0-alpha.27",
   "license": "Apache-2.0",
   "description": "Vite plugin for Tileflow map style development and static artifacts.",
   "engines": {
@@ -41,14 +41,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@tileflow/dev": ">=0.1.0-alpha.30 <0.1.0-beta.0"
+    "@tileflow/dev": ">=0.1.0-alpha.45 <0.1.0-beta.0"
   },
   "peerDependencies": {
     "vite": ">=5 <9"
   },
   "devDependencies": {
-    "vite": "^8.0.16",
-    "@tileflow/maps": "0.1.0-alpha.8"
+    "vite": "^8.3.4",
+    "@tileflow/maps": "0.1.0-alpha.22"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean --external vite --platform node",