ts-maps 0.2.7 → 0.3.0

package/dist/core-map/symbols/index.js

@@ -0,0 +1,501 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core-map/symbols/CollisionIndex.ts
+class CollisionIndex {
+  _cellSize;
+  _cols;
+  _rows;
+  _cells;
+  constructor(opts) {
+    this._cellSize = opts?.cellSize ?? 64;
+    const width = opts?.width ?? 1;
+    const height = opts?.height ?? 1;
+    this._cols = Math.max(1, Math.ceil(width / this._cellSize));
+    this._rows = Math.max(1, Math.ceil(height / this._cellSize));
+    this._cells = [];
+    for (let i = 0;i < this._cols * this._rows; i++)
+      this._cells.push([]);
+  }
+  tryInsert(box) {
+    const range = this._cellRange(box);
+    for (let cy = range.y0;cy <= range.y1; cy++) {
+      for (let cx = range.x0;cx <= range.x1; cx++) {
+        const bucket = this._cells[cy * this._cols + cx];
+        for (const other of bucket) {
+          if (!overlaps(box, other))
+            continue;
+          if (other.priority === undefined || box.priority === undefined)
+            return false;
+          if (other.priority >= box.priority)
+            return false;
+        }
+      }
+    }
+    this._insertBucketed(box, range);
+    return true;
+  }
+  insert(box) {
+    this._insertBucketed(box, this._cellRange(box));
+  }
+  clear() {
+    for (let i = 0;i < this._cells.length; i++)
+      this._cells[i] = [];
+  }
+  _cellRange(box) {
+    const cs = this._cellSize;
+    let x0 = Math.floor(box.minX / cs);
+    let y0 = Math.floor(box.minY / cs);
+    let x1 = Math.floor(box.maxX / cs);
+    let y1 = Math.floor(box.maxY / cs);
+    if (x0 < 0)
+      x0 = 0;
+    if (y0 < 0)
+      y0 = 0;
+    if (x1 > this._cols - 1)
+      x1 = this._cols - 1;
+    if (y1 > this._rows - 1)
+      y1 = this._rows - 1;
+    if (x1 < x0)
+      x1 = x0;
+    if (y1 < y0)
+      y1 = y0;
+    return { x0, y0, x1, y1 };
+  }
+  _insertBucketed(box, range) {
+    for (let cy = range.y0;cy <= range.y1; cy++) {
+      for (let cx = range.x0;cx <= range.x1; cx++) {
+        this._cells[cy * this._cols + cx].push(box);
+      }
+    }
+  }
+}
+function overlaps(a, b) {
+  if (a.maxX < b.minX)
+    return false;
+  if (a.minX > b.maxX)
+    return false;
+  if (a.maxY < b.minY)
+    return false;
+  if (a.minY > b.maxY)
+    return false;
+  return true;
+}
+
+// src/core-map/symbols/GlyphAtlas.ts
+function styleKey(k) {
+  if (!k)
+    return "r";
+  return `${k.italic ? "i" : "r"}${k.bold ? "b" : ""}`;
+}
+function cacheKey(k) {
+  return `${k.codePoint}:${styleKey(k)}`;
+}
+
+class GlyphAtlas {
+  canvas;
+  _ctx;
+  _fontFamily;
+  _fontSize;
+  _padding;
+  _glyphs;
+  _shelfY;
+  _shelfX;
+  _shelfH;
+  constructor(opts) {
+    this._fontFamily = opts?.fontFamily ?? "system-ui, -apple-system, Segoe UI, Roboto";
+    this._fontSize = opts?.fontSize ?? 24;
+    this._padding = opts?.padding ?? 4;
+    const bucketSize = opts?.bucketSize ?? 512;
+    this.canvas = document.createElement("canvas");
+    this.canvas.width = bucketSize;
+    this.canvas.height = bucketSize;
+    this._ctx = this.canvas.getContext("2d");
+    this._glyphs = new Map;
+    this._shelfX = 0;
+    this._shelfY = 0;
+    this._shelfH = 0;
+  }
+  getOrAddGlyph(codePoint, style) {
+    const key = {
+      codePoint,
+      italic: !!style?.italic,
+      bold: !!style?.bold
+    };
+    const existing = this._glyphs.get(cacheKey(key));
+    if (existing)
+      return existing;
+    return this._rasterize(key);
+  }
+  measure(text, style) {
+    let width = 0;
+    let height = 0;
+    for (const ch of text) {
+      const cp = ch.codePointAt(0) ?? 0;
+      const g = this.getOrAddGlyph(cp, style);
+      width += g.advance;
+      if (g.height > height)
+        height = g.height;
+    }
+    return { width, height };
+  }
+  drawText(ctx, text, x, y, options) {
+    const style = { italic: !!options.italic, bold: !!options.bold };
+    const scale = options.size / this._fontSize;
+    if (options.haloColor && options.haloWidth && options.haloWidth > 0) {
+      ctx.save();
+      ctx.globalCompositeOperation = "destination-over";
+      ctx.fillStyle = options.haloColor;
+      this._drawRun(ctx, text, x, y, scale, style, options.haloWidth);
+      ctx.restore();
+    }
+    ctx.save();
+    ctx.fillStyle = options.color;
+    this._drawRun(ctx, text, x, y, scale, style, 0);
+    ctx.restore();
+  }
+  _buildSDF(imageData) {
+    const w = imageData.width;
+    const h = imageData.height;
+    const radius = this._padding;
+    const INF = 1 << 20;
+    const inside = new Int32Array(w * h);
+    const outside = new Int32Array(w * h);
+    for (let i = 0;i < w * h; i++) {
+      const a = imageData.data[i * 4 + 3];
+      if (a >= 128) {
+        outside[i] = INF;
+        inside[i] = 0;
+      } else {
+        outside[i] = 0;
+        inside[i] = INF;
+      }
+    }
+    chamfer34(outside, w, h);
+    chamfer34(inside, w, h);
+    const out = createImageData(w, h);
+    for (let i = 0;i < w * h; i++) {
+      const d = (outside[i] - inside[i]) / 3;
+      let v = 128 - d / radius * 128;
+      if (v < 0)
+        v = 0;
+      else if (v > 255)
+        v = 255;
+      out.data[i * 4 + 0] = 255;
+      out.data[i * 4 + 1] = 255;
+      out.data[i * 4 + 2] = 255;
+      out.data[i * 4 + 3] = v | 0;
+    }
+    return out;
+  }
+  _drawRun(ctx, text, x, y, scale, style, haloInflate) {
+    let pen = x;
+    for (const ch of text) {
+      const cp = ch.codePointAt(0) ?? 0;
+      const g = this.getOrAddGlyph(cp, style);
+      if (g.width > 0 && g.height > 0) {
+        const dx = pen + g.bearingX * scale - haloInflate;
+        const dy = y - g.bearingY * scale - haloInflate;
+        const dw = g.width * scale + haloInflate * 2;
+        const dh = g.height * scale + haloInflate * 2;
+        ctx.drawImage(this.canvas, g.x, g.y, g.width, g.height, dx, dy, dw, dh);
+      }
+      pen += g.advance * scale;
+    }
+  }
+  _rasterize(key) {
+    const ctx = this._ctx;
+    if (!ctx) {
+      const metrics2 = {
+        codePoint: key.codePoint,
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        advance: this._fontSize * 0.6,
+        bearingX: 0,
+        bearingY: 0
+      };
+      this._glyphs.set(cacheKey(key), metrics2);
+      return metrics2;
+    }
+    const font = this._buildFontSpec(key);
+    ctx.font = font;
+    const ch = String.fromCodePoint(key.codePoint);
+    const m = ctx.measureText(ch);
+    const advance = m.width && m.width > 0 ? m.width : this._fontSize * 0.6;
+    const ascent = m.actualBoundingBoxAscent && m.actualBoundingBoxAscent > 0 ? m.actualBoundingBoxAscent : this._fontSize * 0.8;
+    const descent = m.actualBoundingBoxDescent && m.actualBoundingBoxDescent > 0 ? m.actualBoundingBoxDescent : this._fontSize * 0.2;
+    const pad = this._padding;
+    const bmpW = Math.max(1, Math.ceil(advance)) + pad * 2;
+    const bmpH = Math.max(1, Math.ceil(ascent + descent)) + pad * 2;
+    const scratch = document.createElement("canvas");
+    scratch.width = bmpW;
+    scratch.height = bmpH;
+    const sctx = scratch.getContext("2d");
+    if (sctx) {
+      sctx.font = font;
+      sctx.fillStyle = "#000";
+      sctx.textBaseline = "alphabetic";
+      sctx.fillText(ch, pad, pad + ascent);
+      try {
+        const src = sctx.getImageData(0, 0, bmpW, bmpH);
+        const sdf = this._buildSDF(src);
+        sctx.putImageData(sdf, 0, 0);
+      } catch {}
+    }
+    if (this._shelfX + bmpW > this.canvas.width) {
+      this._shelfY += this._shelfH;
+      this._shelfX = 0;
+      this._shelfH = 0;
+    }
+    if (this._shelfY + bmpH > this.canvas.height)
+      this._growAtlas(Math.max(this.canvas.width * 2, this._shelfY + bmpH));
+    if (this._shelfX + bmpW > this.canvas.width)
+      this._growAtlas(Math.max(this.canvas.width * 2, this._shelfX + bmpW));
+    const dx = this._shelfX;
+    const dy = this._shelfY;
+    ctx.drawImage(scratch, dx, dy);
+    this._shelfX += bmpW;
+    if (bmpH > this._shelfH)
+      this._shelfH = bmpH;
+    const metrics = {
+      codePoint: key.codePoint,
+      x: dx,
+      y: dy,
+      width: bmpW,
+      height: bmpH,
+      advance,
+      bearingX: -pad,
+      bearingY: ascent + pad
+    };
+    this._glyphs.set(cacheKey(key), metrics);
+    return metrics;
+  }
+  _buildFontSpec(key) {
+    const parts = [];
+    if (key.italic)
+      parts.push("italic");
+    if (key.bold)
+      parts.push("bold");
+    parts.push(`${this._fontSize}px`);
+    parts.push(this._fontFamily);
+    return parts.join(" ");
+  }
+  _growAtlas(newSide) {
+    const old = this.canvas;
+    const target = document.createElement("canvas");
+    target.width = Math.max(newSide, old.width);
+    target.height = Math.max(newSide, old.height);
+    const tctx = target.getContext("2d");
+    if (tctx)
+      tctx.drawImage(old, 0, 0);
+    this.canvas = target;
+    this._ctx = tctx;
+  }
+}
+function createImageData(width, height) {
+  const data = new Uint8ClampedArray(width * height * 4);
+  const ctor = globalThis.ImageData;
+  if (typeof ctor === "function") {
+    try {
+      return new ctor(data, width, height);
+    } catch {}
+  }
+  return { data, width, height, colorSpace: "srgb" };
+}
+function chamfer34(buf, w, h) {
+  for (let y = 0;y < h; y++) {
+    for (let x = 0;x < w; x++) {
+      const i = y * w + x;
+      let v = buf[i];
+      if (y > 0) {
+        if (x > 0) {
+          const c = buf[i - w - 1] + 4;
+          if (c < v)
+            v = c;
+        }
+        const c2 = buf[i - w] + 3;
+        if (c2 < v)
+          v = c2;
+        if (x < w - 1) {
+          const c3 = buf[i - w + 1] + 4;
+          if (c3 < v)
+            v = c3;
+        }
+      }
+      if (x > 0) {
+        const c4 = buf[i - 1] + 3;
+        if (c4 < v)
+          v = c4;
+      }
+      buf[i] = v;
+    }
+  }
+  for (let y = h - 1;y >= 0; y--) {
+    for (let x = w - 1;x >= 0; x--) {
+      const i = y * w + x;
+      let v = buf[i];
+      if (y < h - 1) {
+        if (x < w - 1) {
+          const c = buf[i + w + 1] + 4;
+          if (c < v)
+            v = c;
+        }
+        const c2 = buf[i + w] + 3;
+        if (c2 < v)
+          v = c2;
+        if (x > 0) {
+          const c3 = buf[i + w - 1] + 4;
+          if (c3 < v)
+            v = c3;
+        }
+      }
+      if (x < w - 1) {
+        const c4 = buf[i + 1] + 3;
+        if (c4 < v)
+          v = c4;
+      }
+      buf[i] = v;
+    }
+  }
+}
+
+// src/core-map/symbols/IconAtlas.ts
+class IconAtlas {
+  canvas;
+  _ctx;
+  _sprites;
+  _cursorX;
+  _cursorY;
+  _rowH;
+  constructor() {
+    this.canvas = document.createElement("canvas");
+    this.canvas.width = 512;
+    this.canvas.height = 512;
+    this._ctx = this.canvas.getContext("2d");
+    this._sprites = new Map;
+    this._cursorX = 0;
+    this._cursorY = 0;
+    this._rowH = 0;
+  }
+  addSprite(entry, source) {
+    const w = entry.width;
+    const h = entry.height;
+    if (this._cursorX + w > this.canvas.width) {
+      this._cursorY += this._rowH;
+      this._cursorX = 0;
+      this._rowH = 0;
+    }
+    if (this._cursorY + h > this.canvas.height)
+      this._grow(Math.max(this.canvas.width * 2, this._cursorY + h));
+    const dx = this._cursorX;
+    const dy = this._cursorY;
+    const ctx = this._ctx;
+    if (ctx) {
+      if (isImageData(source)) {
+        const detour = document.createElement("canvas");
+        detour.width = source.width;
+        detour.height = source.height;
+        const dctx = detour.getContext("2d");
+        if (dctx) {
+          dctx.putImageData(source, 0, 0);
+          ctx.drawImage(detour, entry.x, entry.y, w, h, dx, dy, w, h);
+        }
+      } else {
+        ctx.drawImage(source, entry.x, entry.y, w, h, dx, dy, w, h);
+      }
+    }
+    const packed = {
+      id: entry.id,
+      x: dx,
+      y: dy,
+      width: w,
+      height: h,
+      pixelRatio: entry.pixelRatio ?? 1
+    };
+    this._sprites.set(entry.id, packed);
+    this._cursorX += w;
+    if (h > this._rowH)
+      this._rowH = h;
+  }
+  get(id) {
+    return this._sprites.get(id);
+  }
+  drawIcon(ctx, id, dx, dy, opts) {
+    const s = this._sprites.get(id);
+    if (!s)
+      return;
+    const target = opts?.size ?? s.width;
+    const scale = target / s.width;
+    const w = s.width * scale;
+    const h = s.height * scale;
+    if (opts?.rotation) {
+      ctx.save();
+      ctx.translate(dx, dy);
+      ctx.rotate(opts.rotation);
+      ctx.drawImage(this.canvas, s.x, s.y, s.width, s.height, -w / 2, -h / 2, w, h);
+      ctx.restore();
+    } else {
+      ctx.drawImage(this.canvas, s.x, s.y, s.width, s.height, dx - w / 2, dy - h / 2, w, h);
+    }
+  }
+  _grow(newSide) {
+    const old = this.canvas;
+    const target = document.createElement("canvas");
+    target.width = Math.max(newSide, old.width);
+    target.height = Math.max(newSide, old.height);
+    const tctx = target.getContext("2d");
+    if (tctx)
+      tctx.drawImage(old, 0, 0);
+    this.canvas = target;
+    this._ctx = tctx;
+  }
+}
+function isImageData(v) {
+  if (!v || typeof v !== "object")
+    return false;
+  const anyV = v;
+  return typeof anyV.width === "number" && typeof anyV.height === "number" && (anyV.data instanceof Uint8ClampedArray || anyV.data instanceof Uint8Array);
+}
+export {
+  IconAtlas,
+  GlyphAtlas,
+  CollisionIndex
+};

package/dist/index.d.ts

@@ -1,4 +1,2 @@
-import { VectorMap } from './vector-map';
-export * from './types';
-export { VectorMap };
-export default VectorMap;
+export * from './core-map/index';
+export { default } from './core-map/index';