leaflet-rotate 0.2.8 → 0.3.0

package/.github/workflows/ci.yml

@@ -0,0 +1,21 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci
+      - run: npx playwright install --with-deps chromium
+      - run: npm test

package/README.md

@@ -30,7 +30,7 @@ cd ./leaflet-rotate
 npm i         # install dependencies
 npm run dev   # start dev server at: http://localhost:8080
 npm run build # generate "dist" files (once)
-npm run test  # test all "*.spec.js" files (once)
+npm run test  # build and run browser tests
 ```
 
 After that you can start developing inside the `src` and `test` folders (eg. open "http://localhost:8080/test" in your browser to preview changes).
@@ -41,6 +41,10 @@ After that you can start developing inside the `src` and `test` folders (eg. ope
 
 Be aware that this library overrides notable parts of leaflet core via the [L.Class.include()](https://leafletjs.com/examples/extending/extending-1-classes.html) function in order to make the rotate feature usable as a standalone plug-in.
 
+For [Leaflet.heat](https://github.com/Leaflet/Leaflet.heat) or [heatmap.js's Leaflet plugin](https://github.com/pa7/heatmap.js/tree/master/plugins/leaflet-heatmap), load `misc/leaflet-heat-rotate.js` after the heatmap plugin. It adapts heat redraw coordinates to the rotated pane.
+
+Markers with `rotateWithView: true` can use `keepUpright: true` to remain readable while preserving their line alignment.
+
 Initial changes to this project have been apported by comparing the following branches: [https://github.com/Leaflet/Leaflet/compare/main...fnicollet:rotate-master](https://github.com/Leaflet/Leaflet/compare/main...fnicollet:rotate-master) (ref: [bac6c7d](https://github.com/fnicollet/Leaflet/tree/4ab6342f74516e7087dcd2ae786c721f36addf9e))
 
 ---

package/build/build.js

@@ -0,0 +1,69 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { build as esbuildBuild, context, transform } from 'esbuild';
+
+const options = {
+  entryPoints: ['src/index.js'],
+  bundle: true,
+  format: 'iife',
+  globalName: 'leafletRotate',
+  sourcemap: true,
+  outdir: 'dist',
+  entryNames: 'leaflet-rotate-src',
+};
+const minifiedOptions = { ...options, entryNames: 'leaflet-rotate', minify: true };
+const debugMinifiedOptions = {
+  entryPoints: ['lib/debug.js'],
+  outfile: 'lib/debug.min.js',
+  minify: true,
+  plugins: [{
+    name: 'minify-debug-templates',
+    setup(build) {
+      build.onLoad({ filter: /[\\/]lib[\\/]debug\.js$/ }, async ({ path }) => {
+        const source = await readFile(path, 'utf8');
+        const style = source.match(/<style>([\s\S]*?)<\/style>/);
+        if (!style) throw new Error(`Could not find debug stylesheet in ${path}`);
+
+        const { code } = await transform(style[1], { loader: 'css', minify: true });
+        const contents = source
+          .replace(style[0], `<style>${code.trim()}</style>`)
+          .replace(/`([^`]*<[^`]*?)`/gs, (template, html) => {
+            if (html.includes('${')) return template;
+            return `\`${html.replace(/<!--[\s\S]*?-->/g, '').replace(/>\s+</g, '><').trim()}\``;
+          });
+
+        return {
+          contents,
+          loader: 'js',
+          watchFiles: [path],
+        };
+      });
+    },
+  }],
+};
+
+export async function build({ watch = false } = {}) {
+  await mkdir('dist', { recursive: true });
+
+  if (!watch) {
+    await Promise.all([
+      esbuildBuild(options),
+      esbuildBuild(minifiedOptions),
+      esbuildBuild(debugMinifiedOptions),
+    ]);
+    return;
+  }
+
+  const builders = await Promise.all([
+    context(options),
+    context(minifiedOptions),
+    context(debugMinifiedOptions),
+  ]);
+  await Promise.all(builders.map(builder => builder.watch()));
+  return () => Promise.all(builders.map(builder => builder.dispose()));
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  await build();
+}

package/build/dev.js

@@ -0,0 +1,24 @@
+import { build } from './build.js';
+import { startServer } from './server.js';
+
+const server = await startServer(8080);
+let stopBuild;
+
+try {
+  stopBuild = await build({ watch: true });
+  console.log('Serving on http://127.0.0.1:8080');
+} catch (error) {
+  await new Promise((resolve, reject) => server.close(err => err ? reject(err) : resolve()));
+  throw error;
+}
+
+let stopping = false;
+async function stop() {
+  if (stopping) return;
+  stopping = true;
+  await stopBuild();
+  await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+}
+
+process.on('SIGINT', stop);
+process.on('SIGTERM', stop);

package/build/server.js

@@ -0,0 +1,104 @@
+import { createReadStream } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { extname, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const types = {
+  '.css': 'text/css; charset=utf-8',
+  '.geojson': 'application/geo+json',
+  '.gif': 'image/gif',
+  '.gpx': 'application/gpx+xml',
+  '.html': 'text/html; charset=utf-8',
+  '.ico': 'image/x-icon',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.js': 'text/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.kml': 'application/vnd.google-earth.kml+xml',
+  '.map': 'application/json; charset=utf-8',
+  '.md': 'text/markdown; charset=utf-8',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.tcx': 'application/vnd.garmin.tcx+xml',
+  '.txt': 'text/plain; charset=utf-8',
+  '.webp': 'image/webp',
+  '.xml': 'text/xml; charset=utf-8',
+};
+
+const escapeHtml = value => value.replace(/[&<>"']/g, char => ({
+  '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+})[char]);
+
+export function startServer(port = 8080) {
+  const server = createServer(async (request, response) => {
+    if (request.method !== 'GET' && request.method !== 'HEAD') {
+      response.writeHead(405, { Allow: 'GET, HEAD' }).end();
+      return;
+    }
+
+    try {
+      const pathname = decodeURIComponent(new URL(request.url, 'http://localhost').pathname);
+      if (pathname.includes('\0')) {
+        response.writeHead(400).end('Bad request');
+        return;
+      }
+      const file = resolve(root, `.${pathname}`);
+      if (file !== root && !file.startsWith(root + sep)) {
+        response.writeHead(403).end();
+        return;
+      }
+
+      const info = await stat(file);
+      const target = info.isDirectory() ? resolve(file, 'index.html') : file;
+      let content;
+      try {
+        content = await stat(target);
+      } catch (error) {
+        if (!info.isDirectory() || error.code !== 'ENOENT') throw error;
+        const entries = await readdir(file, { withFileTypes: true });
+        const base = new URL(request.url, 'http://localhost').pathname.replace(/\/?$/, '/');
+        const links = entries.map(entry => {
+          const suffix = entry.isDirectory() ? '/' : '';
+          const href = `${base}${encodeURIComponent(entry.name)}${suffix}`;
+          return `<li><a href="${escapeHtml(href)}">${escapeHtml(entry.name)}${suffix}</a></li>`;
+        }).join('');
+        response.writeHead(200, { 'Content-Type': types['.html'] });
+        response.end(request.method === 'HEAD' ? undefined : `<ul>${links}</ul>`);
+        return;
+      }
+      if (!content.isFile()) {
+        response.writeHead(404).end();
+        return;
+      }
+      response.writeHead(200, {
+        'Content-Type': types[extname(target).toLowerCase()] ?? 'application/octet-stream',
+      });
+      if (request.method === 'HEAD') response.end();
+      else createReadStream(target).on('error', error => {
+        console.error(error);
+        response.destroy(error);
+      }).pipe(response);
+    } catch (error) {
+      if (error instanceof URIError || error.code === 'ERR_INVALID_URL') {
+        response.writeHead(400).end('Bad request');
+        return;
+      }
+      if (error.code === 'ENOENT' || error.code === 'ENOTDIR' || error.code === 'EISDIR') {
+        response.writeHead(404).end('Not found');
+        return;
+      }
+      console.error(error);
+      response.writeHead(500).end('Internal server error');
+    }
+  });
+
+  return new Promise((resolveServer, reject) => {
+    server.once('error', reject);
+    server.listen(port, '127.0.0.1', () => {
+      server.off('error', reject);
+      resolveServer(server);
+    });
+  });
+}

package/cucumber.mjs

@@ -0,0 +1,5 @@
+export default {
+    paths: ['test/features/**/*.feature'],
+    import: ['test/support/**/*.js', 'test/steps/**/*.js'],
+    format: ['progress'],
+};