@spatika/react 1.0.0 → 1.2.0

package/src/lib/geo.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { featureId, fitFeatures, geoPath, mercator } from "./geo";
+
+describe("geo", () => {
+  it("projects the equator to the mercator midpoint", () => {
+    const [x, y] = mercator([0, 0]);
+    expect(x).toBeCloseTo(0.5);
+    expect(y).toBeCloseTo(0.5);
+  });
+
+  it("builds a closed polygon path fitted to a viewport", () => {
+    const features = [
+      {
+        type: "Feature" as const,
+        id: "box",
+        properties: { name: "Box" },
+        geometry: {
+          type: "Polygon" as const,
+          coordinates: [
+            [
+              [0, 0],
+              [10, 0],
+              [10, 10],
+              [0, 10],
+              [0, 0],
+            ],
+          ],
+        },
+      },
+    ];
+    const project = fitFeatures(features, 200, 100, 10);
+    const d = geoPath(features[0]!.geometry, project);
+    expect(d.startsWith("M")).toBe(true);
+    expect(d.includes("Z")).toBe(true);
+    expect(featureId(features[0]!)).toBe("box");
+  });
+
+  it("projects a point to a move-to command", () => {
+    const d = geoPath({ type: "Point", coordinates: [0, 0] }, mercator);
+    expect(d.startsWith("M")).toBe(true);
+  });
+});

package/src/lib/geo.ts

@@ -0,0 +1,138 @@
+/**
+ * Tiny GeoJSON helpers — Mercator / equirectangular, no d3-geo.
+ */
+
+export type GeoPosition = [number, number];
+
+export type GeoJsonGeometry =
+  | { type: "Polygon"; coordinates: GeoPosition[][] }
+  | { type: "MultiPolygon"; coordinates: GeoPosition[][][] }
+  | { type: "Point"; coordinates: GeoPosition }
+  | { type: "LineString"; coordinates: GeoPosition[] }
+  | { type: "MultiLineString"; coordinates: GeoPosition[][] };
+
+export type GeoJsonFeature = {
+  type: "Feature";
+  id?: string | number;
+  properties?: Record<string, unknown> | null;
+  geometry: GeoJsonGeometry | null;
+};
+
+export type GeoJsonFeatureCollection = {
+  type: "FeatureCollection";
+  features: GeoJsonFeature[];
+};
+
+export type GeoProjectionKind = "mercator" | "equirectangular";
+
+export function mercator([lon, lat]: GeoPosition): [number, number] {
+  const x = (lon + 180) / 360;
+  const clamped = Math.min(85.051129, Math.max(-85.051129, lat));
+  const sin = Math.sin((clamped * Math.PI) / 180);
+  const y = 0.5 - Math.log((1 + sin) / (1 - sin)) / (4 * Math.PI);
+  return [x, y];
+}
+
+export function equirectangular([lon, lat]: GeoPosition): [number, number] {
+  return [(lon + 180) / 360, (90 - lat) / 180];
+}
+
+export function projectLonLat(pos: GeoPosition, kind: GeoProjectionKind): [number, number] {
+  return kind === "equirectangular" ? equirectangular(pos) : mercator(pos);
+}
+
+export function featureId(feature: GeoJsonFeature, idProperty = "id"): string {
+  if (feature.id != null) return String(feature.id);
+  const value = feature.properties?.[idProperty] ?? feature.properties?.name;
+  return value != null ? String(value) : "";
+}
+
+function walkGeometry(geometry: GeoJsonGeometry, visit: (pos: GeoPosition) => void) {
+  if (geometry.type === "Point") {
+    visit(geometry.coordinates);
+    return;
+  }
+  if (geometry.type === "LineString") {
+    geometry.coordinates.forEach(visit);
+    return;
+  }
+  if (geometry.type === "MultiLineString") {
+    geometry.coordinates.forEach((line) => line.forEach(visit));
+    return;
+  }
+  if (geometry.type === "Polygon") {
+    geometry.coordinates.forEach((ring) => ring.forEach(visit));
+    return;
+  }
+  geometry.coordinates.forEach((poly) => poly.forEach((ring) => ring.forEach(visit)));
+}
+
+export function walkFeatures(features: GeoJsonFeature[], visit: (pos: GeoPosition) => void) {
+  for (const feature of features) {
+    if (feature.geometry) walkGeometry(feature.geometry, visit);
+  }
+}
+
+function ringPath(ring: GeoPosition[], project: (pos: GeoPosition) => [number, number]): string {
+  if (!ring.length) return "";
+  const pts = ring.map(project);
+  return `M${pts.map(([x, y]) => `${x} ${y}`).join("L")}Z`;
+}
+
+function linePath(line: GeoPosition[], project: (pos: GeoPosition) => [number, number]): string {
+  if (!line.length) return "";
+  const pts = line.map(project);
+  return `M${pts.map(([x, y]) => `${x} ${y}`).join("L")}`;
+}
+
+export function geoPath(
+  geometry: GeoJsonGeometry,
+  project: (pos: GeoPosition) => [number, number],
+): string {
+  if (geometry.type === "Polygon") {
+    return geometry.coordinates.map((ring) => ringPath(ring, project)).join(" ");
+  }
+  if (geometry.type === "MultiPolygon") {
+    return geometry.coordinates
+      .map((poly) => poly.map((ring) => ringPath(ring, project)).join(" "))
+      .join(" ");
+  }
+  if (geometry.type === "LineString") return linePath(geometry.coordinates, project);
+  if (geometry.type === "MultiLineString") {
+    return geometry.coordinates.map((line) => linePath(line, project)).join(" ");
+  }
+  const [x, y] = project(geometry.coordinates);
+  return `M${x} ${y}m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0`;
+}
+
+export function fitFeatures(
+  features: GeoJsonFeature[],
+  width: number,
+  height: number,
+  padding: number,
+  kind: GeoProjectionKind = "mercator",
+): (pos: GeoPosition) => [number, number] {
+  const raw = (pos: GeoPosition) => projectLonLat(pos, kind);
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  walkFeatures(features, (pos) => {
+    const [x, y] = raw(pos);
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  });
+  const bw = Math.max(1e-6, maxX - minX);
+  const bh = Math.max(1e-6, maxY - minY);
+  const innerW = Math.max(1, width - padding * 2);
+  const innerH = Math.max(1, height - padding * 2);
+  const scale = Math.min(innerW / bw, innerH / bh);
+  const tx = padding + (innerW - bw * scale) / 2;
+  const ty = padding + (innerH - bh * scale) / 2;
+  return (pos) => {
+    const [x, y] = raw(pos);
+    return [tx + (x - minX) * scale, ty + (y - minY) * scale];
+  };
+}

package/src/lib/iso.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { ellipseSlicePath, isoBoxFaces, isoPoint } from "./iso";
+
+describe("iso", () => {
+  it("projects isometric points with y up", () => {
+    const origin = isoPoint(0, 0, 0, 40, 80);
+    const raised = isoPoint(0, 10, 0, 40, 80);
+    expect(raised.y).toBeLessThan(origin.y);
+  });
+
+  it("emits three faces for a box", () => {
+    const faces = isoBoxFaces(0, 0, 0, 10, 20, 8, 40, 80);
+    expect(faces.front.startsWith("M")).toBe(true);
+    expect(faces.top).not.toEqual(faces.front);
+    expect(faces.side).not.toEqual(faces.top);
+  });
+
+  it("draws an elliptical pie slice", () => {
+    const d = ellipseSlicePath(50, 40, 30, 12, 0, 90);
+    expect(d.includes("A30 12")).toBe(true);
+  });
+});

package/src/lib/iso.ts

@@ -0,0 +1,102 @@
+/**
+ * Isometric 2.5D helpers for SVG bar and pie charts.
+ */
+
+const COS = Math.cos(Math.PI / 6);
+const SIN = Math.sin(Math.PI / 6);
+
+export function isoPoint(
+  x: number,
+  y: number,
+  z: number,
+  originX: number,
+  originY: number,
+): { x: number; y: number } {
+  return {
+    x: originX + (x - z) * COS,
+    y: originY - y + (x + z) * SIN,
+  };
+}
+
+function poly(points: Array<{ x: number; y: number }>): string {
+  if (!points.length) return "";
+  return `M${points.map((p) => `${p.x} ${p.y}`).join("L")}Z`;
+}
+
+export type IsoBoxFaces = {
+  front: string;
+  top: string;
+  side: string;
+};
+
+/** Axis-aligned box: x/z on the ground plane, y up. */
+export function isoBoxFaces(
+  x: number,
+  y0: number,
+  z: number,
+  w: number,
+  h: number,
+  d: number,
+  originX: number,
+  originY: number,
+): IsoBoxFaces {
+  const p = (px: number, py: number, pz: number) => isoPoint(px, py, pz, originX, originY);
+  const a = p(x, y0, z);
+  const b = p(x + w, y0, z);
+  const c = p(x + w, y0 + h, z);
+  const e = p(x, y0 + h, z);
+  const f = p(x + w, y0, z + d);
+  const g = p(x + w, y0 + h, z + d);
+  const k = p(x, y0 + h, z + d);
+  return {
+    front: poly([a, b, c, e]),
+    top: poly([e, c, g, k]),
+    side: poly([b, f, g, c]),
+  };
+}
+
+export function ellipsePoint(
+  cx: number,
+  cy: number,
+  rx: number,
+  ry: number,
+  angleDeg: number,
+): { x: number; y: number } {
+  const rad = ((angleDeg - 90) * Math.PI) / 180;
+  return { x: cx + rx * Math.cos(rad), y: cy + ry * Math.sin(rad) };
+}
+
+export function ellipseSlicePath(
+  cx: number,
+  cy: number,
+  rx: number,
+  ry: number,
+  startAngle: number,
+  endAngle: number,
+): string {
+  const start = ellipsePoint(cx, cy, rx, ry, startAngle);
+  const end = ellipsePoint(cx, cy, rx, ry, endAngle);
+  const sweep = ((endAngle - startAngle) % 360 + 360) % 360;
+  if (sweep <= 0) return "";
+  const large = sweep > 180 ? 1 : 0;
+  return `M${cx} ${cy} L${start.x} ${start.y} A${rx} ${ry} 0 ${large} 1 ${end.x} ${end.y} Z`;
+}
+
+export function ellipseWallPath(
+  cx: number,
+  cy: number,
+  rx: number,
+  ry: number,
+  startAngle: number,
+  endAngle: number,
+  thickness: number,
+): string {
+  const top0 = ellipsePoint(cx, cy, rx, ry, startAngle);
+  const top1 = ellipsePoint(cx, cy, rx, ry, endAngle);
+  const bot0 = { x: top0.x, y: top0.y + thickness };
+  const bot1 = { x: top1.x, y: top1.y + thickness };
+  const sweep = ((endAngle - startAngle) % 360 + 360) % 360;
+  if (sweep <= 0) return "";
+  const large = sweep > 180 ? 1 : 0;
+  return `M${bot0.x} ${bot0.y} L${top0.x} ${top0.y} A${rx} ${ry} 0 ${large} 1 ${top1.x} ${top1.y} L${bot1.x} ${bot1.y} A${rx} ${ry} 0 ${large} 0 ${bot0.x} ${bot0.y} Z`;
+}

package/src/lib/rrule.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { expandEventOccurrences, parseRRule } from "./rrule";
+import { normalizeEvents } from "./scheduler";
+
+describe("rrule", () => {
+  it("parses FREQ, INTERVAL, BYDAY, and COUNT", () => {
+    const rule = parseRRule("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE;COUNT=6");
+    expect(rule).toMatchObject({
+      freq: "WEEKLY",
+      interval: 2,
+      count: 6,
+    });
+    expect(rule?.byDay?.map((item) => item.weekday)).toEqual([1, 3]);
+  });
+
+  it("expands weekly BYDAY into the visible range", () => {
+    const [event] = normalizeEvents([
+      {
+        id: "standup",
+        title: "Standup",
+        start: "2026-08-03T10:00:00",
+        end: "2026-08-03T10:15:00",
+        rrule: "FREQ=WEEKLY;BYDAY=MO,WE,FR",
+      },
+    ]);
+    const occurrences = expandEventOccurrences(
+      event,
+      new Date(2026, 7, 3),
+      new Date(2026, 7, 8),
+    );
+    expect(occurrences.map((item) => item.start.getDay())).toEqual([1, 3, 5]);
+    expect(occurrences.every((item) => item.id === "standup")).toBe(true);
+  });
+
+  it("skips exception dates", () => {
+    const [event] = normalizeEvents([
+      {
+        id: "daily",
+        title: "Daily",
+        start: "2026-08-03T09:00:00",
+        end: "2026-08-03T09:30:00",
+        rrule: "FREQ=DAILY;COUNT=5",
+        exceptionDates: ["2026-08-04"],
+      },
+    ]);
+    const occurrences = expandEventOccurrences(
+      event,
+      new Date(2026, 7, 3),
+      new Date(2026, 7, 10),
+    );
+    expect(occurrences.map((item) => item.start.getDate())).toEqual([3, 5, 6, 7]);
+  });
+});

package/src/lib/rrule.ts

@@ -0,0 +1,281 @@
+import type { NormalizedEvent, SchedulerEvent } from "./scheduler";
+
+function toDate(value: Date | string): Date {
+  if (value instanceof Date) return new Date(value.getTime());
+  const dateOnly = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (dateOnly) {
+    return new Date(Number(dateOnly[1]), Number(dateOnly[2]) - 1, Number(dateOnly[3]));
+  }
+  return new Date(value);
+}
+
+function startOfDay(date: Date): Date {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+function addDays(date: Date, amount: number): Date {
+  const next = new Date(date.getTime());
+  next.setDate(next.getDate() + amount);
+  return next;
+}
+
+function addMonths(date: Date, amount: number): Date {
+  const next = new Date(date.getTime());
+  next.setMonth(next.getMonth() + amount);
+  return next;
+}
+
+function addMs(date: Date, ms: number): Date {
+  return new Date(date.getTime() + ms);
+}
+
+const WEEKDAY: Record<string, number> = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6,
+};
+
+export type ParsedRRule = {
+  freq: "DAILY" | "WEEKLY" | "MONTHLY" | "YEARLY";
+  interval: number;
+  count?: number;
+  until?: Date;
+  byDay?: { weekday: number; nth?: number }[];
+  byMonthDay?: number[];
+};
+
+export function parseRRule(rrule: string): ParsedRRule | null {
+  const parts = rrule
+    .replace(/^RRULE:/i, "")
+    .split(";")
+    .map((part) => part.trim())
+    .filter(Boolean);
+  const map = new Map<string, string>();
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    if (key && value) map.set(key.toUpperCase(), value);
+  }
+  const freq = map.get("FREQ") as ParsedRRule["freq"] | undefined;
+  if (!freq || !["DAILY", "WEEKLY", "MONTHLY", "YEARLY"].includes(freq)) return null;
+
+  const untilRaw = map.get("UNTIL");
+  let until: Date | undefined;
+  if (untilRaw) {
+    const compact = /^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?$/.exec(untilRaw);
+    until = compact
+      ? new Date(
+          Date.UTC(
+            Number(compact[1]),
+            Number(compact[2]) - 1,
+            Number(compact[3]),
+            Number(compact[4] ?? 23),
+            Number(compact[5] ?? 59),
+            Number(compact[6] ?? 59),
+          ),
+        )
+      : toDate(untilRaw);
+  }
+
+  const byDay = map.get("BYDAY")
+    ?.split(",")
+    .flatMap((token) => {
+      const match = /^(-?\d+)?(SU|MO|TU|WE|TH|FR|SA)$/.exec(token.trim().toUpperCase());
+      if (!match) return [];
+      return [{ weekday: WEEKDAY[match[2]], nth: match[1] ? Number(match[1]) : undefined }];
+    });
+
+  const byMonthDay = map
+    .get("BYMONTHDAY")
+    ?.split(",")
+    .map((value) => Number(value))
+    .filter((value) => Number.isFinite(value));
+
+  return {
+    freq,
+    interval: Math.max(1, Number(map.get("INTERVAL") ?? 1) || 1),
+    count: map.get("COUNT") ? Math.max(1, Number(map.get("COUNT"))) : undefined,
+    until,
+    byDay,
+    byMonthDay,
+  };
+}
+
+function nthWeekdayOfMonth(year: number, month: number, weekday: number, nth: number): Date | null {
+  if (nth > 0) {
+    const first = new Date(year, month, 1);
+    const shift = (weekday - first.getDay() + 7) % 7;
+    const day = 1 + shift + (nth - 1) * 7;
+    const date = new Date(year, month, day);
+    return date.getMonth() === month ? date : null;
+  }
+  const last = new Date(year, month + 1, 0);
+  const shift = (last.getDay() - weekday + 7) % 7;
+  const day = last.getDate() - shift + (nth + 1) * 7;
+  const date = new Date(year, month, day);
+  return date.getMonth() === month ? date : null;
+}
+
+function matchesByDay(date: Date, rule: ParsedRRule): boolean {
+  if (!rule.byDay?.length) return true;
+  return rule.byDay.some((item) => {
+    if (item.weekday !== date.getDay()) return false;
+    if (item.nth == null) return true;
+    const found = nthWeekdayOfMonth(date.getFullYear(), date.getMonth(), item.weekday, item.nth);
+    return found ? found.getDate() === date.getDate() : false;
+  });
+}
+
+function exceptionSet(dates: Array<Date | string> | undefined): Set<string> {
+  const set = new Set<string>();
+  for (const value of dates ?? []) {
+    const date = startOfDay(toDate(value));
+    set.add(`${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`);
+  }
+  return set;
+}
+
+function dayKey(date: Date): string {
+  return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+}
+
+/**
+ * Expand a recurring event into occurrences overlapping [rangeStart, rangeEnd).
+ * Non-recurring events are returned as a single occurrence.
+ */
+export function expandEventOccurrences(
+  event: NormalizedEvent,
+  rangeStart: Date,
+  rangeEnd: Date,
+  source?: SchedulerEvent,
+): NormalizedEvent[] {
+  if (!event.rrule) return [event];
+  const rule = parseRRule(event.rrule);
+  if (!rule) return [event];
+
+  const duration = Math.max(0, event.end.getTime() - event.start.getTime());
+  const exceptions = exceptionSet(source?.exceptionDates ?? event.exceptionDates);
+  const occurrences: NormalizedEvent[] = [];
+  const seed = new Date(event.start.getTime());
+  let emitted = 0;
+  const hardCap = rule.count ?? 400;
+
+  const pushIfVisible = (start: Date) => {
+    if (start.getTime() < seed.getTime() - 60_000) return;
+    if (exceptions.has(dayKey(start))) return;
+    if (rule.until && start.getTime() > rule.until.getTime()) return;
+    const end = addMs(start, duration || 3_600_000);
+    if (end.getTime() <= rangeStart.getTime() || start.getTime() >= rangeEnd.getTime()) return;
+    occurrences.push({
+      ...event,
+      start,
+      end,
+      occurrenceStart: start,
+    });
+  };
+
+  if (rule.freq === "DAILY") {
+    let cursor = new Date(seed.getTime());
+    while (emitted < hardCap && cursor.getTime() < rangeEnd.getTime() + duration) {
+      if (!rule.until || cursor.getTime() <= rule.until.getTime()) {
+        pushIfVisible(new Date(cursor.getTime()));
+        emitted += 1;
+      }
+      cursor = addDays(cursor, rule.interval);
+      if (rule.count && emitted >= rule.count) break;
+    }
+    return occurrences;
+  }
+
+  if (rule.freq === "WEEKLY") {
+    const days = rule.byDay?.length
+      ? [...new Set(rule.byDay.map((item) => item.weekday))].sort()
+      : [seed.getDay()];
+    let weekStart = addDays(startOfDay(seed), -seed.getDay());
+    while (emitted < hardCap && weekStart.getTime() < rangeEnd.getTime()) {
+      for (const weekday of days) {
+        const start = new Date(
+          weekStart.getFullYear(),
+          weekStart.getMonth(),
+          weekStart.getDate() + weekday,
+          seed.getHours(),
+          seed.getMinutes(),
+          seed.getSeconds(),
+        );
+        if (start.getTime() < seed.getTime() - 60_000) continue;
+        if (rule.until && start.getTime() > rule.until.getTime()) continue;
+        pushIfVisible(start);
+        emitted += 1;
+        if (rule.count && emitted >= rule.count) return occurrences;
+      }
+      weekStart = addDays(weekStart, 7 * rule.interval);
+    }
+    return occurrences;
+  }
+
+  if (rule.freq === "MONTHLY") {
+    let year = seed.getFullYear();
+    let month = seed.getMonth();
+    while (emitted < hardCap) {
+      const monthStart = new Date(year, month, 1);
+      if (monthStart.getTime() > rangeEnd.getTime()) break;
+      const candidates: Date[] = [];
+      if (rule.byDay?.length) {
+        for (const item of rule.byDay) {
+          const found = nthWeekdayOfMonth(year, month, item.weekday, item.nth ?? 1);
+          if (found) {
+            candidates.push(
+              new Date(year, month, found.getDate(), seed.getHours(), seed.getMinutes(), seed.getSeconds()),
+            );
+          }
+        }
+      } else {
+        const days = rule.byMonthDay?.length ? rule.byMonthDay : [seed.getDate()];
+        for (const day of days) {
+          const date = new Date(year, month, day, seed.getHours(), seed.getMinutes(), seed.getSeconds());
+          if (date.getMonth() === month) candidates.push(date);
+        }
+      }
+      for (const start of candidates.sort((a, b) => a.getTime() - b.getTime())) {
+        if (rule.until && start.getTime() > rule.until.getTime()) continue;
+        pushIfVisible(start);
+        emitted += 1;
+        if (rule.count && emitted >= rule.count) return occurrences;
+      }
+      const next = addMonths(new Date(year, month, 1), rule.interval);
+      year = next.getFullYear();
+      month = next.getMonth();
+    }
+    return occurrences;
+  }
+
+  let cursor = new Date(seed.getTime());
+  while (emitted < hardCap && cursor.getTime() < rangeEnd.getTime() + duration) {
+    if (matchesByDay(cursor, rule) && (!rule.until || cursor.getTime() <= rule.until.getTime())) {
+      pushIfVisible(new Date(cursor.getTime()));
+      emitted += 1;
+    }
+    cursor = addMonths(cursor, 12 * rule.interval);
+    if (rule.count && emitted >= rule.count) break;
+  }
+  return occurrences;
+}
+
+export function expandVisibleEvents(
+  events: NormalizedEvent[],
+  rangeStart: Date,
+  rangeEnd: Date,
+  sources: SchedulerEvent[] = [],
+): NormalizedEvent[] {
+  return events.flatMap((event) =>
+    expandEventOccurrences(
+      event,
+      rangeStart,
+      rangeEnd,
+      sources.find((item) => item.id === event.id),
+    ),
+  );
+}