geokernel-electron 1.0.2

package/src/native-types.js

@@ -0,0 +1,101 @@
+"use strict";
+
+const koffi = require("koffi");
+
+const GeoKernelViewerExtent = koffi.struct("GeoKernelViewerExtent", {
+  xMin: "double",
+  yMin: "double",
+  xMax: "double",
+  yMax: "double",
+});
+
+const GeoKernelViewerScreenRectangle = koffi.struct("GeoKernelViewerScreenRectangle", {
+  left: "int",
+  top: "int",
+  right: "int",
+  bottom: "int",
+});
+
+const GeoKernelViewerRouteSummary = koffi.struct("GeoKernelViewerRouteSummary", {
+  succeeded: "bool",
+  totalDistance: "double",
+  totalTime: "double",
+  cost: "double",
+  fromSnapDistance: "double",
+  toSnapDistance: "double",
+  routeLayerIndex: "int",
+});
+
+const GeoKernelViewerEventData = koffi.struct("GeoKernelViewerEventData", {
+  eventType: "int",
+  intValue: "int",
+  intValue2: "int",
+  doubleValue: "double",
+  extent: GeoKernelViewerExtent,
+  screenRectangle: GeoKernelViewerScreenRectangle,
+});
+
+const GeoKernelViewerEventCallback = koffi.proto("GeoKernelViewerEventCallback", "void", [
+  koffi.pointer(GeoKernelViewerEventData),
+  "str16",
+  "void *",
+]);
+
+const GeoKernelViewerLayerLoadProgressCallback = koffi.proto(
+  "GeoKernelViewerLayerLoadProgressCallback",
+  "void",
+  ["int", "str16", "void *"],
+);
+
+const GeoKernelViewerLayerLoadCancellationCallback = koffi.proto(
+  "GeoKernelViewerLayerLoadCancellationCallback",
+  "bool",
+  ["void *"],
+);
+
+const GeoKernelViewerSpatialIndexStateCallback = koffi.proto(
+  "GeoKernelViewerSpatialIndexStateCallback",
+  "void",
+  ["int", "void *"],
+);
+
+const TYPES = Object.freeze({
+  void: "void",
+  void_p: "void *",
+  size_t: "size_t",
+  int: "int",
+  bool: "bool",
+  double: "double",
+  wchar_p: "str16",
+  out_wchar_p: koffi.out("str16"),
+  double_p: koffi.pointer("double"),
+  out_double_p: koffi.out(koffi.pointer("double")),
+  int_p: koffi.pointer("int"),
+  out_int_p: koffi.out(koffi.pointer("int")),
+  ubyte_p: koffi.pointer("uint8_t"),
+  out_ubyte_p: koffi.out(koffi.pointer("uint8_t")),
+  extent: GeoKernelViewerExtent,
+  extent_p: koffi.pointer(GeoKernelViewerExtent),
+  out_extent_p: koffi.out(koffi.pointer(GeoKernelViewerExtent)),
+  screen_rect: GeoKernelViewerScreenRectangle,
+  screen_rect_p: koffi.pointer(GeoKernelViewerScreenRectangle),
+  out_screen_rect_p: koffi.out(koffi.pointer(GeoKernelViewerScreenRectangle)),
+  route_summary_p: koffi.pointer(GeoKernelViewerRouteSummary),
+  out_route_summary_p: koffi.out(koffi.pointer(GeoKernelViewerRouteSummary)),
+  event_callback: koffi.pointer(GeoKernelViewerEventCallback),
+  progress_callback: koffi.pointer(GeoKernelViewerLayerLoadProgressCallback),
+  cancel_callback: koffi.pointer(GeoKernelViewerLayerLoadCancellationCallback),
+  index_state_callback: koffi.pointer(GeoKernelViewerSpatialIndexStateCallback),
+});
+
+module.exports = {
+  GeoKernelViewerEventCallback,
+  GeoKernelViewerEventData,
+  GeoKernelViewerExtent,
+  GeoKernelViewerLayerLoadCancellationCallback,
+  GeoKernelViewerLayerLoadProgressCallback,
+  GeoKernelViewerRouteSummary,
+  GeoKernelViewerScreenRectangle,
+  GeoKernelViewerSpatialIndexStateCallback,
+  TYPES,
+};

package/src/native.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const path = require("path");
+const koffi = require("koffi");
+
+const { configureRuntimeEnvironment, findBinDir } = require("./runtime");
+const { SIGNATURES } = require("./native-signatures");
+const nativeTypes = require("./native-types");
+
+class GeoKernelNativeLibrary {
+  constructor(binDir) {
+    this.binDir = findBinDir(binDir);
+    configureRuntimeEnvironment(this.binDir);
+    this.dll = koffi.load(path.join(this.binDir, "GeoKernel.Viewer.dll"));
+    this.functions = new Map();
+  }
+
+  getFunction(name) {
+    if (!Object.prototype.hasOwnProperty.call(SIGNATURES, name)) {
+      throw new Error(`Unknown GeoKernel native function: ${name}`);
+    }
+
+    if (!this.functions.has(name)) {
+      const [returnTypeName, argTypeNames] = SIGNATURES[name];
+      const returnType = typeFor(returnTypeName);
+      const argTypes = argTypeNames.map(typeFor);
+      this.functions.set(name, this.dll.func(name, returnType, argTypes));
+    }
+
+    return this.functions.get(name);
+  }
+
+  bindAll() {
+    for (const name of functionNames()) {
+      this.getFunction(name);
+    }
+  }
+}
+
+function typeFor(name) {
+  const type = nativeTypes.TYPES[name];
+  if (type === undefined) {
+    throw new Error(`Unknown GeoKernel native type: ${name}`);
+  }
+
+  return type;
+}
+
+function functionNames() {
+  return Object.keys(SIGNATURES);
+}
+
+function createNativeLibrary(binDir) {
+  return new GeoKernelNativeLibrary(binDir);
+}
+
+module.exports = {
+  ...nativeTypes,
+  GeoKernelNativeLibrary,
+  SIGNATURES,
+  createNativeLibrary,
+  functionNames,
+};

package/src/runtime.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function packageRoot() {
+  return path.resolve(__dirname, "..");
+}
+
+function findBinDir(binDir) {
+  const candidates = [
+    binDir,
+    process.env.GEOKERNEL_BIN,
+    path.join(packageRoot(), "bin"),
+    "D:\\projects\\GeoKernel\\outputs\\Release",
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const dllPath = path.join(candidate, "GeoKernel.Viewer.dll");
+    if (fs.existsSync(dllPath)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(`Could not find GeoKernel.Viewer.dll. Searched: ${candidates.join(", ")}`);
+}
+
+function prependPath(value) {
+  const parts = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  const exists = parts.some((part) => part.toLowerCase() === value.toLowerCase());
+  if (!exists) {
+    process.env.PATH = `${value}${path.delimiter}${process.env.PATH || ""}`;
+  }
+}
+
+function configureRuntimeEnvironment(binDir) {
+  prependPath(binDir);
+
+  const assetsDir = path.join(packageRoot(), "assets", "images");
+  if (fs.existsSync(assetsDir)) {
+    process.env.GEOKERNEL_ICON_DIR ||= assetsDir;
+  }
+
+  const gdalData = path.join(binDir, "gdal-data");
+  if (fs.existsSync(gdalData)) {
+    process.env.GDAL_DATA ||= gdalData;
+  }
+
+  const projData = path.join(binDir, "proj-data");
+  if (fs.existsSync(projData)) {
+    process.env.PROJ_LIB ||= projData;
+  }
+
+  const gdalPlugins = path.join(binDir, "gdalplugins");
+  if (fs.existsSync(gdalPlugins)) {
+    process.env.GDAL_DRIVER_PATH ||= gdalPlugins;
+  }
+
+  const qtPlugins = path.join(binDir, "plugins");
+  const qtPlatforms = path.join(qtPlugins, "platforms");
+  if (fs.existsSync(qtPlatforms)) {
+    process.env.QT_PLUGIN_PATH ||= qtPlugins;
+    process.env.QT_QPA_PLATFORM_PLUGIN_PATH ||= qtPlatforms;
+  }
+}
+
+module.exports = {
+  configureRuntimeEnvironment,
+  findBinDir,
+  packageRoot,
+};

package/src/styles.js

@@ -0,0 +1,70 @@
+"use strict";
+
+class MapStyle {
+  constructor(background, fillColor, lineColor, pointColor, selectedLineColor, fillOpacity = 220, lineWidth = 0.9, pointSize = 6.0) {
+    this.background = background;
+    this.fillColor = fillColor;
+    this.lineColor = lineColor;
+    this.pointColor = pointColor;
+    this.selectedLineColor = selectedLineColor;
+    this.fillOpacity = fillOpacity;
+    this.lineWidth = lineWidth;
+    this.pointSize = pointSize;
+  }
+
+  toLayerStyleJson() {
+    return {
+      fillColor: this.fillColor,
+      fillOpacity: this.fillOpacity,
+      lineColor: this.lineColor,
+      lineWidth: this.lineWidth,
+      pointColor: this.pointColor,
+      pointSize: this.pointSize,
+      selectedLineColor: this.selectedLineColor,
+      selectedLineWidth: Math.max(2.0, this.lineWidth + 1.2),
+      labelColor: "#263B3A",
+      labelFontFamily: "Segoe UI",
+      labelFontSize: 10,
+      labelHaloEnabled: true,
+      labelHaloColor: "#FFFFFF",
+      labelHaloWidth: 1.8,
+    };
+  }
+}
+
+const MAP_STYLES = {
+  "soft-professional": new MapStyle("#F7F9F8", "#DDEBE7", "#6F8D88", "#E85D3D", "#FFD166", 215, 0.9, 6.0),
+  "classic-gis": new MapStyle("#FFFFFF", "#E8F0EA", "#7B8F88", "#D9534F", "#00AEEF", 220, 0.9, 6.0),
+  "dark": new MapStyle("#101418", "#1F2A2E", "#5F7F7A", "#FF6B4A", "#FFD166", 225, 0.9, 6.0),
+  "blueprint": new MapStyle("#0F2A44", "#143E5E", "#6AB7FF", "#FFD166", "#FF595E", 210, 1.0, 6.0),
+  "satellite-overlay": new MapStyle("#1B1B1B", "#FFFFFF", "#FFFFFF", "#FFD166", "#FF9F1C", 8, 1.1, 6.0),
+  "vintage-map": new MapStyle("#F8F2DE", "#EFE6C9", "#947E52", "#8B5E34", "#B85C38", 230, 1.0, 6.0),
+  "pastel": new MapStyle("#FAFAFA", "#E8F4F0", "#95B8AF", "#F28C6A", "#7DCE82", 225, 0.9, 6.0),
+  "midnight-blue": new MapStyle("#08141D", "#112531", "#5B9FB2", "#FF8A5B", "#49D6FF", 230, 1.0, 6.0),
+  "monochrome": new MapStyle("#FFFFFF", "#FFFFFF", "#000000", "#000000", "#666666", 255, 1.0, 6.0),
+  "neon": new MapStyle("#0B0B0B", "#1B1B1B", "#00FFFF", "#00FF88", "#FF00FF", 230, 1.0, 7.0),
+  "google-light": new MapStyle("#F2F1EC", "#F2F1EC", "#C9C9C9", "#EA4335", "#4285F4", 235, 0.8, 6.0),
+  "arcgis-pro-modern": new MapStyle("#EEF4EF", "#EEF4EF", "#A3B2A4", "#C94F3D", "#00A2FF", 230, 0.9, 6.0),
+  "qgis-green": new MapStyle("#E4F1D9", "#E4F1D9", "#719C5A", "#D95F02", "#F3B600", 230, 0.9, 6.0),
+  "github": new MapStyle("#F6F8FA", "#EAF2F8", "#8AA4B0", "#CF222E", "#0969DA", 230, 0.9, 6.0),
+  "material-design": new MapStyle("#FAFAFA", "#FAFAFA", "#79747E", "#6750A4", "#FFB74D", 230, 0.9, 6.0),
+};
+
+function argb(color, alpha = 255) {
+  const normalized = color.trim().replace(/^#/, "");
+  if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
+    throw new Error(`Expected #RRGGBB color, got ${color}`);
+  }
+
+  const red = parseInt(normalized.slice(0, 2), 16);
+  const green = parseInt(normalized.slice(2, 4), 16);
+  const blue = parseInt(normalized.slice(4, 6), 16);
+  const unsigned = ((alpha & 0xff) << 24) | (red << 16) | (green << 8) | blue;
+  return unsigned > 0x7fffffff ? unsigned - 0x100000000 : unsigned;
+}
+
+module.exports = {
+  MAP_STYLES,
+  MapStyle,
+  argb,
+};

package/src/types.js

@@ -0,0 +1,120 @@
+"use strict";
+
+const ViewerTool = Object.freeze({
+  PAN: 0,
+  ZOOM_BOX: 1,
+  INFO: 2,
+  SELECT: 3,
+  ADD_POINT: 4,
+  ADD_POLYLINE: 5,
+  ADD_POLYGON: 6,
+  MOVE_FEATURE: 7,
+  ROUTE: 8,
+  EDIT_VERTICES: 9,
+});
+
+const ShapeType = Object.freeze({
+  UNKNOWN: 0,
+  POINT: 1,
+  POLYLINE: 3,
+  POLYGON: 5,
+  MULTI_POINT: 8,
+  POINT_Z: 11,
+  POLYLINE_Z: 13,
+  POLYGON_Z: 15,
+  MULTI_POINT_Z: 18,
+});
+
+const SpatialIndexType = Object.freeze({
+  LINEAR: 0,
+  RTREE: 1,
+  RTREE_HILBERT: 2,
+  QUAD_TREE: 3,
+});
+
+const RenderBackendPreference = Object.freeze({
+  AUTO: 0,
+  QT_PAINTER: 1,
+  SKIA_CPU: 2,
+  SKIA_GPU: 3,
+});
+
+const RoutingCostMetric = Object.freeze({
+  DISTANCE: 0,
+  TRAVEL_TIME: 1,
+});
+
+const OverlayAnchor = Object.freeze({
+  NONE: 0,
+  TOP_LEFT: 1,
+  TOP_RIGHT: 2,
+  BOTTOM_LEFT: 3,
+  BOTTOM_RIGHT: 4,
+});
+
+const MeasureMode = Object.freeze({
+  DISTANCE: 0,
+  AREA: 1,
+});
+
+const ClassificationMethod = Object.freeze({
+  MANUAL: 0,
+  DEFINED_INTERVAL: 1,
+  EQUAL_INTERVAL: 2,
+  QUANTILE: 3,
+  NATURAL_BREAKS: 4,
+  QUARTILE: 5,
+  STANDARD_DEVIATION: 6,
+  STANDARD_DEVIATION_WITH_CENTRAL: 7,
+  GEOMETRICAL_INTERVAL: 8,
+  KMEANS: 9,
+  KMEANS_SPATIAL: 10,
+});
+
+const ColorRampMode = Object.freeze({
+  CONTINUOUS: 0,
+  DISCRETE: 1,
+});
+
+const SymbolStyleTarget = Object.freeze({
+  COLOR: 0,
+  SIZE_OR_WIDTH: 1,
+  OUTLINE_COLOR: 2,
+  OUTLINE_WIDTH: 3,
+});
+
+function point(x, y) {
+  return Object.freeze({ x, y });
+}
+
+function extent(xMin, yMin, xMax, yMax) {
+  return Object.freeze({ xMin, yMin, xMax, yMax });
+}
+
+function routeSummary(value) {
+  return Object.freeze({
+    succeeded: Boolean(value.succeeded),
+    totalDistance: value.totalDistance,
+    totalTime: value.totalTime,
+    cost: value.cost,
+    fromSnapDistance: value.fromSnapDistance,
+    toSnapDistance: value.toSnapDistance,
+    routeLayerIndex: value.routeLayerIndex,
+  });
+}
+
+module.exports = {
+  ClassificationMethod,
+  ColorRampMode,
+  MeasureMode,
+  OverlayAnchor,
+  RenderBackendPreference,
+  RoutingCostMetric,
+  ShapeType,
+  SpatialIndexType,
+  SymbolStyleTarget,
+  ViewerTool,
+  extent,
+  point,
+  routeSummary,
+};

package/src/viewer-helpers.js

@@ -0,0 +1,124 @@
+"use strict";
+
+function jsonText(value) {
+  if (value === undefined || value === null) {
+    return "";
+  }
+
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+
+function parseJson(text, fallback) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return fallback;
+  }
+
+  return JSON.parse(trimmed);
+}
+
+function readWideText(fn, handle, ...args) {
+  let bufferLength = 4096;
+
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    const out = ["\0".repeat(bufferLength)];
+    const length = fn(handle, ...args, out, bufferLength);
+    if (length < 0) {
+      throw new Error(`GeoKernel text call failed with result ${length}.`);
+    }
+
+    const text = trimNull(out[0]);
+    if (length < bufferLength - 1) {
+      return text;
+    }
+
+    bufferLength = Math.max(bufferLength * 2, length + 1);
+  }
+
+  throw new Error("GeoKernel text buffer was too small after multiple attempts.");
+}
+
+function trimNull(value) {
+  const index = value.indexOf("\0");
+  return index >= 0 ? value.slice(0, index) : value;
+}
+
+function readWideJson(fn, handle, ...args) {
+  return readWideText(fn, handle, ...args);
+}
+
+function xyArray(points) {
+  if (points instanceof Float64Array) {
+    return points;
+  }
+
+  if (!Array.isArray(points)) {
+    throw new TypeError("Expected an array of points.");
+  }
+
+  if (points.length === 0) {
+    return new Float64Array();
+  }
+
+  if (typeof points[0] === "number") {
+    return Float64Array.from(points);
+  }
+
+  const values = [];
+  for (const point of points) {
+    if (Array.isArray(point)) {
+      values.push(Number(point[0]), Number(point[1]));
+    } else {
+      values.push(Number(point.x), Number(point.y));
+    }
+  }
+
+  return Float64Array.from(values);
+}
+
+function partsArrays(parts) {
+  if (!Array.isArray(parts)) {
+    throw new TypeError("Expected an array of parts.");
+  }
+
+  const values = [];
+  const counts = [];
+  for (const part of parts) {
+    const flat = xyArray(part);
+    values.push(...flat);
+    counts.push(flat.length / 2);
+  }
+
+  return {
+    xy: Float64Array.from(values),
+    counts: Int32Array.from(counts),
+  };
+}
+
+function extentObject(value) {
+  if (Array.isArray(value)) {
+    return {
+      xMin: Number(value[0]),
+      yMin: Number(value[1]),
+      xMax: Number(value[2]),
+      yMax: Number(value[3]),
+    };
+  }
+
+  return {
+    xMin: Number(value.xMin ?? value.x_min),
+    yMin: Number(value.yMin ?? value.y_min),
+    xMax: Number(value.xMax ?? value.x_max),
+    yMax: Number(value.yMax ?? value.y_max),
+  };
+}
+
+module.exports = {
+  extentObject,
+  jsonText,
+  parseJson,
+  partsArrays,
+  readWideJson,
+  readWideText,
+  xyArray,
+};