pdf-mapview 0.1.0

package/dist/ingest/cli.js

@@ -0,0 +1,697 @@
+#!/usr/bin/env node
+import { resolve, join, extname, basename, dirname } from 'path';
+import { cac } from 'cac';
+import { randomUUID } from 'crypto';
+import { writeFile, readFile, rm, mkdir } from 'fs/promises';
+import sharp2 from 'sharp';
+import { z } from 'zod';
+import { createCanvas, DOMMatrix, ImageData, Path2D } from '@napi-rs/canvas';
+
+// src/ingest/storage/memory.ts
+function memoryStorageAdapter() {
+  const artifacts = [];
+  const record = (kind, path, contentType, bytes) => {
+    const artifact = {
+      kind,
+      path,
+      contentType,
+      size: bytes.byteLength
+    };
+    artifacts.push(artifact);
+    return artifact;
+  };
+  return {
+    async writeTile(args) {
+      return record("tile", `tiles/${args.z}/${args.x}/${args.y}.${args.ext}`, args.contentType, args.bytes);
+    },
+    async writeManifest(args) {
+      return record("manifest", args.path, args.contentType, args.bytes);
+    },
+    async writeAsset(args) {
+      return record(args.kind, args.path, args.contentType, args.bytes);
+    },
+    async finalize(_args) {
+      return {
+        artifacts: [...artifacts]
+      };
+    }
+  };
+}
+
+// src/shared/bytes.ts
+function toUint8Array(input) {
+  if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+}
+
+// src/ingest/pipeline/inspectInput.ts
+async function inspectInput(input) {
+  if (typeof input === "string") {
+    const bytes = await readFile(input);
+    return {
+      bytes: toUint8Array(bytes),
+      originalFilename: basename(input),
+      ext: extname(input).slice(1).toLowerCase() || void 0
+    };
+  }
+  return {
+    bytes: toUint8Array(input)
+  };
+}
+async function normalizeImage(options) {
+  const { data, info } = await sharp2(options.bytes, { failOn: "none" }).rotate().resize({
+    width: options.maxDimension,
+    height: options.maxDimension,
+    fit: "inside",
+    withoutEnlargement: true
+  }).flatten({
+    background: options.background
+  }).png().toBuffer({ resolveWithObject: true });
+  return {
+    bytes: new Uint8Array(data),
+    width: info.width,
+    height: info.height,
+    mimeType: "image/png"
+  };
+}
+async function buildTilePyramid(options) {
+  const maxZoom = Math.max(
+    0,
+    Math.ceil(Math.log2(Math.max(options.width, options.height) / options.tileSize))
+  );
+  const levels = [];
+  const tiles = [];
+  const source = Buffer.from(options.image);
+  for (let z3 = 0; z3 <= maxZoom; z3 += 1) {
+    const scale = 1 / 2 ** (maxZoom - z3);
+    const width = Math.max(1, Math.ceil(options.width * scale));
+    const height = Math.max(1, Math.ceil(options.height * scale));
+    const columns = Math.max(1, Math.ceil(width / options.tileSize));
+    const rows = Math.max(1, Math.ceil(height / options.tileSize));
+    levels.push({
+      z: z3,
+      width,
+      height,
+      columns,
+      rows,
+      scale
+    });
+    const levelBuffer = await sharp2(source, { failOn: "none" }).resize({
+      width,
+      height,
+      fit: "fill"
+    }).png().toBuffer();
+    for (let y = 0; y < rows; y += 1) {
+      for (let x = 0; x < columns; x += 1) {
+        const left = x * options.tileSize;
+        const top = y * options.tileSize;
+        const extractWidth = Math.min(options.tileSize, width - left);
+        const extractHeight = Math.min(options.tileSize, height - top);
+        const tileBuffer = await sharp2(levelBuffer, { failOn: "none" }).extract({
+          left,
+          top,
+          width: extractWidth,
+          height: extractHeight
+        }).toFormat(options.format, formatOptions(options.format, options.quality)).toBuffer();
+        tiles.push({
+          kind: "tile",
+          path: `tiles/${z3}/${x}/${y}.${extensionForFormat(options.format)}`,
+          contentType: contentTypeForFormat(options.format),
+          bytes: new Uint8Array(tileBuffer)
+        });
+      }
+    }
+  }
+  const previewBuffer = await sharp2(source, { failOn: "none" }).resize({
+    width: 1024,
+    height: 1024,
+    fit: "inside",
+    withoutEnlargement: true
+  }).webp({ quality: 80 }).toBuffer();
+  return {
+    levels,
+    tiles,
+    preview: {
+      kind: "preview",
+      path: "preview.webp",
+      contentType: "image/webp",
+      bytes: new Uint8Array(previewBuffer)
+    }
+  };
+}
+function formatOptions(format, quality) {
+  switch (format) {
+    case "jpeg":
+      return { quality };
+    case "png":
+      return {};
+    case "webp":
+    default:
+      return { quality };
+  }
+}
+function extensionForFormat(format) {
+  return format === "jpeg" ? "jpg" : format;
+}
+function contentTypeForFormat(format) {
+  switch (format) {
+    case "jpeg":
+      return "image/jpeg";
+    case "png":
+      return "image/png";
+    case "webp":
+    default:
+      return "image/webp";
+  }
+}
+var normalizedPointSchema = z.object({
+  x: z.number().finite().min(0).max(1),
+  y: z.number().finite().min(0).max(1)
+});
+var normalizedRectSchema = z.object({
+  x: z.number().finite().min(0).max(1),
+  y: z.number().finite().min(0).max(1),
+  width: z.number().finite().min(0).max(1),
+  height: z.number().finite().min(0).max(1)
+});
+var regionFeatureSchema = z.object({
+  id: z.string().min(1),
+  geometry: z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("polygon"),
+      points: z.array(normalizedPointSchema).min(3)
+    }),
+    z.object({
+      type: z.literal("rectangle"),
+      rect: normalizedRectSchema
+    }),
+    z.object({
+      type: z.literal("point"),
+      point: normalizedPointSchema,
+      radius: z.number().finite().positive().optional()
+    }),
+    z.object({
+      type: z.literal("label"),
+      point: normalizedPointSchema,
+      text: z.string().min(1)
+    })
+  ]),
+  label: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var regionCollectionSchema = z.object({
+  type: z.literal("FeatureCollection"),
+  regions: z.array(regionFeatureSchema)
+});
+
+// src/shared/manifest.ts
+var tileLevelSchema = z.object({
+  z: z.number().int().min(0),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  columns: z.number().int().positive(),
+  rows: z.number().int().positive(),
+  scale: z.number().positive()
+});
+var manifestSchema = z.object({
+  version: z.literal(1),
+  kind: z.literal("pdf-map"),
+  id: z.string().min(1),
+  source: z.object({
+    type: z.union([z.literal("pdf"), z.literal("image")]),
+    originalFilename: z.string().optional(),
+    page: z.number().int().positive().optional(),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    mimeType: z.string().optional()
+  }),
+  coordinateSpace: z.object({
+    normalized: z.literal(true),
+    width: z.number().int().positive(),
+    height: z.number().int().positive()
+  }),
+  tiles: z.object({
+    tileSize: z.number().int().positive(),
+    format: z.union([z.literal("webp"), z.literal("jpeg"), z.literal("png")]),
+    minZoom: z.number().int().min(0),
+    maxZoom: z.number().int().min(0),
+    pathTemplate: z.string().min(1),
+    levels: z.array(tileLevelSchema)
+  }),
+  view: z.object({
+    defaultCenter: z.tuple([
+      z.number().finite().min(0).max(1),
+      z.number().finite().min(0).max(1)
+    ]),
+    defaultZoom: z.number().finite(),
+    minZoom: z.number().finite(),
+    maxZoom: z.number().finite()
+  }),
+  overlays: z.object({
+    inline: regionCollectionSchema.optional(),
+    url: z.string().optional()
+  }).optional(),
+  assets: z.object({
+    preview: z.string().optional()
+  }).optional(),
+  metadata: z.object({
+    title: z.string().optional(),
+    createdAt: z.string().optional()
+  }).catchall(z.unknown()).optional()
+});
+function createManifest(input) {
+  return manifestSchema.parse({
+    version: 1,
+    kind: "pdf-map",
+    ...input
+  });
+}
+
+// src/ingest/pipeline/manifestBuilder.ts
+function buildManifest(options) {
+  const minZoom = options.levels[0]?.z ?? 0;
+  const maxZoom = options.levels[options.levels.length - 1]?.z ?? 0;
+  return createManifest({
+    id: options.id,
+    source: {
+      type: options.sourceType,
+      originalFilename: options.originalFilename,
+      page: options.page,
+      width: options.width,
+      height: options.height,
+      mimeType: options.mimeType
+    },
+    coordinateSpace: {
+      normalized: true,
+      width: options.width,
+      height: options.height
+    },
+    tiles: {
+      tileSize: options.tileSize,
+      format: options.tileFormat,
+      minZoom,
+      maxZoom,
+      pathTemplate: withBaseUrl(options.baseUrl, `tiles/{z}/{x}/{y}.${options.tileFormat === "jpeg" ? "jpg" : options.tileFormat}`),
+      levels: options.levels
+    },
+    view: {
+      defaultCenter: [0.5, 0.5],
+      defaultZoom: 1,
+      minZoom: 0,
+      maxZoom: Math.max(maxZoom + 2, 6)
+    },
+    overlays: options.inlineOverlays || options.overlayUrl ? {
+      inline: options.inlineOverlays,
+      url: options.overlayUrl ? withBaseUrl(options.baseUrl, options.overlayUrl) : void 0
+    } : void 0,
+    assets: options.previewPath ? {
+      preview: withBaseUrl(options.baseUrl, options.previewPath)
+    } : void 0,
+    metadata: {
+      title: options.title,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+}
+function withBaseUrl(baseUrl, path) {
+  if (!baseUrl) {
+    return path;
+  }
+  if (/^https?:\/\//.test(baseUrl)) {
+    return new URL(path.replace(/^\//, ""), ensureTrailingSlash(baseUrl)).toString();
+  }
+  return joinRelativeUrl(baseUrl, path);
+}
+function ensureTrailingSlash(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function joinRelativeUrl(baseUrl, path) {
+  const normalizedBase = ensureLeadingSlash(stripTrailingSlash(baseUrl));
+  const normalizedPath = stripLeadingSlash(path);
+  if (!normalizedPath) {
+    return normalizedBase || "/";
+  }
+  return normalizedBase ? `${normalizedBase}/${normalizedPath}` : `/${normalizedPath}`;
+}
+function stripLeadingSlash(value) {
+  return value.replace(/^\/+/, "");
+}
+function stripTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function ensureLeadingSlash(value) {
+  if (!value) {
+    return "";
+  }
+  return value.startsWith("/") ? value : `/${value}`;
+}
+
+// src/ingest/pipeline/writeArtifacts.ts
+async function writeArtifacts(adapter, manifest, files) {
+  const uploaded = [];
+  for (const file of files) {
+    if (file.kind === "tile") {
+      const match = file.path.match(/^tiles\/(\d+)\/(\d+)\/(\d+)\.[^.]+$/);
+      if (!match) {
+        throw new Error(`Invalid tile path: ${file.path}`);
+      }
+      uploaded.push(
+        await adapter.writeTile({
+          z: Number(match[1]),
+          x: Number(match[2]),
+          y: Number(match[3]),
+          ext: file.path.split(".").pop() ?? "bin",
+          bytes: file.bytes,
+          contentType: file.contentType
+        })
+      );
+      continue;
+    }
+    if (file.kind === "manifest") {
+      uploaded.push(
+        await adapter.writeManifest({
+          path: file.path,
+          bytes: file.bytes,
+          contentType: "application/json"
+        })
+      );
+      continue;
+    }
+    if (!adapter.writeAsset) {
+      throw new Error(`Storage adapter does not support writing ${file.kind} assets.`);
+    }
+    uploaded.push(
+      await adapter.writeAsset({
+        kind: file.kind,
+        path: file.path,
+        bytes: file.bytes,
+        contentType: file.contentType
+      })
+    );
+  }
+  const storage = await adapter.finalize({
+    manifest,
+    artifacts: uploaded
+  });
+  return {
+    uploaded,
+    storage
+  };
+}
+
+// src/ingest/ingestImage.ts
+async function ingestImage(options) {
+  const inspected = await inspectInput(options.input);
+  const normalized = await normalizeImage({
+    bytes: inspected.bytes,
+    maxDimension: options.maxDimension ?? 12288,
+    background: options.background ?? "#ffffff"
+  });
+  return ingestRasterizedImage(normalized, {
+    common: options,
+    id: options.id ?? defaultId(inspected.originalFilename ?? "image"),
+    title: options.title,
+    sourceType: "image",
+    originalFilename: inspected.originalFilename,
+    mimeType: normalized.mimeType
+  });
+}
+async function ingestRasterizedImage(normalized, input) {
+  const tileSize = input.common.tileSize ?? 256;
+  const tileFormat = input.common.tileFormat ?? "webp";
+  const tileQuality = input.common.tileQuality ?? 92;
+  const storage = input.common.storage ?? memoryStorageAdapter();
+  const pyramid = await buildTilePyramid({
+    image: normalized.bytes,
+    width: normalized.width,
+    height: normalized.height,
+    tileSize,
+    format: tileFormat,
+    quality: tileQuality
+  });
+  const overlayPayload = await resolveOverlayPayload(input.common.overlays);
+  const manifest = buildManifest({
+    id: input.id,
+    title: input.title,
+    sourceType: input.sourceType,
+    originalFilename: input.originalFilename,
+    page: input.page,
+    width: normalized.width,
+    height: normalized.height,
+    mimeType: input.mimeType ?? normalized.mimeType,
+    tileSize,
+    tileFormat,
+    levels: pyramid.levels,
+    baseUrl: input.common.baseUrl,
+    inlineOverlays: overlayPayload.inline,
+    overlayUrl: overlayPayload.url,
+    previewPath: pyramid.preview.path
+  });
+  const files = [...pyramid.tiles, pyramid.preview];
+  if (overlayPayload.file) {
+    files.push(overlayPayload.file);
+  }
+  files.push({
+    kind: "manifest",
+    path: "manifest.json",
+    contentType: "application/json",
+    bytes: new TextEncoder().encode(JSON.stringify(manifest, null, 2))
+  });
+  const { uploaded, storage: storageResult } = await writeArtifacts(storage, manifest, files);
+  return {
+    manifest,
+    width: normalized.width,
+    height: normalized.height,
+    tileCount: pyramid.tiles.length,
+    files,
+    uploaded,
+    warnings: [],
+    storage: storageResult
+  };
+}
+async function resolveOverlayPayload(input) {
+  if (!input) {
+    return {};
+  }
+  if (typeof input === "string") {
+    return {
+      url: input
+    };
+  }
+  const bytes = new TextEncoder().encode(JSON.stringify(input, null, 2));
+  if (bytes.byteLength < 64 * 1024) {
+    return {
+      inline: input
+    };
+  }
+  return {
+    url: "regions.json",
+    file: {
+      kind: "overlay",
+      path: "regions.json",
+      contentType: "application/json",
+      bytes
+    }
+  };
+}
+function defaultId(seed) {
+  const safe = seed.replace(/\.[^.]+$/, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe || randomUUID();
+}
+async function rasterizePdf(options) {
+  installNodeCanvasGlobals();
+  const pdfjs = await import('pdfjs-dist/legacy/build/pdf.mjs');
+  const loadingTask = pdfjs.getDocument({
+    data: options.bytes,
+    useSystemFonts: true
+  });
+  const pdf = await loadingTask.promise;
+  const page = await pdf.getPage(options.page);
+  const viewport = page.getViewport({ scale: 1 });
+  const scale = resolveScale({
+    viewportWidth: viewport.width,
+    viewportHeight: viewport.height,
+    maxDimension: options.maxDimension,
+    rasterDpi: options.rasterDpi
+  });
+  const scaledViewport = page.getViewport({
+    scale: scale <= 0 ? 1 : scale
+  });
+  const canvas = createCanvas(Math.ceil(scaledViewport.width), Math.ceil(scaledViewport.height));
+  const context = canvas.getContext("2d");
+  context.fillStyle = options.background;
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  await page.render({
+    canvasContext: context,
+    viewport: scaledViewport
+  }).promise;
+  const png = await canvas.encode("png");
+  await page.cleanup();
+  await pdf.cleanup();
+  await pdf.destroy();
+  return {
+    bytes: new Uint8Array(png),
+    width: canvas.width,
+    height: canvas.height,
+    mimeType: "image/png"
+  };
+}
+function installNodeCanvasGlobals() {
+  if (!("DOMMatrix" in globalThis)) {
+    globalThis.DOMMatrix = DOMMatrix;
+  }
+  if (!("ImageData" in globalThis)) {
+    globalThis.ImageData = ImageData;
+  }
+  if (!("Path2D" in globalThis)) {
+    globalThis.Path2D = Path2D;
+  }
+}
+function resolveScale(options) {
+  if (options.rasterDpi && Number.isFinite(options.rasterDpi) && options.rasterDpi > 0) {
+    return options.rasterDpi / 72;
+  }
+  return Math.min(
+    1,
+    options.maxDimension / Math.max(options.viewportWidth, options.viewportHeight)
+  );
+}
+
+// src/ingest/ingestPdf.ts
+async function ingestPdf(options) {
+  const inspected = await inspectInput(options.input);
+  const page = options.page ?? 1;
+  const rasterized = await rasterizePdf({
+    bytes: inspected.bytes,
+    page,
+    maxDimension: options.maxDimension ?? 12288,
+    rasterDpi: options.rasterDpi,
+    background: options.background ?? "#ffffff"
+  });
+  return ingestRasterizedImage(rasterized, {
+    common: options,
+    id: options.id ?? defaultId2(inspected.originalFilename ?? "pdf"),
+    title: options.title,
+    sourceType: "pdf",
+    originalFilename: inspected.originalFilename,
+    mimeType: "application/pdf",
+    page
+  });
+}
+function defaultId2(seed) {
+  const safe = seed.replace(/\.[^.]+$/, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe || randomUUID();
+}
+function localStorageAdapter(options) {
+  const baseDir = resolve(options.baseDir);
+  const manifestName = options.manifestName ?? "manifest.json";
+  const artifacts = [];
+  let cleaned = false;
+  const ensureParent = async (filePath) => {
+    await mkdir(dirname(filePath), { recursive: true });
+  };
+  const ensureClean = async () => {
+    if (cleaned) {
+      return;
+    }
+    cleaned = true;
+    await rm(baseDir, { recursive: true, force: true });
+  };
+  const write = async (kind, relativePath, contentType, bytes) => {
+    await ensureClean();
+    const path = join(baseDir, relativePath);
+    await ensureParent(path);
+    await writeFile(path, bytes);
+    const artifact = {
+      kind,
+      path,
+      contentType,
+      size: bytes.byteLength
+    };
+    artifacts.push(artifact);
+    return artifact;
+  };
+  return {
+    async writeTile(args) {
+      return write(
+        "tile",
+        `tiles/${args.z}/${args.x}/${args.y}.${args.ext}`,
+        args.contentType,
+        args.bytes
+      );
+    },
+    async writeManifest(args) {
+      return write("manifest", manifestName, args.contentType, args.bytes);
+    },
+    async writeAsset(args) {
+      return write(args.kind, args.path, args.contentType, args.bytes);
+    },
+    async finalize(_args) {
+      return {
+        artifacts: [...artifacts]
+      };
+    }
+  };
+}
+
+// src/ingest/cli.ts
+var cli = cac("pdf-mapview");
+cli.command("ingest <input>", "Ingest a PDF or image into a tiled map manifest").option("--page <page>", "PDF page to ingest", {
+  default: 1
+}).option("--id <id>", "Manifest id").option("--title <title>", "Manifest title").option("--out-dir <outDir>", "Write output to a local directory").option("--type <type>", "Force source type: pdf or image").option("--base-url <baseUrl>", "Base URL for manifest asset references").option("--adapter <adapter>", "Module path for a custom storage adapter factory").option("--adapter-export <name>", "Named export for the custom storage adapter", {
+  default: "default"
+}).option("--tile-size <tileSize>", "Tile size: 256 or 512", {
+  default: 256
+}).option("--format <format>", "Tile format: webp, jpeg, or png", {
+  default: "webp"
+}).option("--quality <quality>", "Tile quality", {
+  default: 92
+}).option("--raster-dpi <rasterDpi>", "Rasterize PDF pages at a fixed DPI").option("--max-dimension <maxDimension>", "Max raster dimension", {
+  default: 12288
+}).action(async (input, flags) => {
+  const outDir = flags.outDir ? resolve(String(flags.outDir)) : void 0;
+  const storage = flags.adapter ? await loadCustomAdapter(String(flags.adapter), String(flags.adapterExport)) : outDir ? localStorageAdapter({
+    baseDir: outDir}) : void 0;
+  const type = String(flags.type ?? inferType(String(input)));
+  const common = {
+    id: flags.id ? String(flags.id) : void 0,
+    title: flags.title ? String(flags.title) : void 0,
+    tileSize: Number(flags.tileSize),
+    tileFormat: String(flags.format),
+    tileQuality: Number(flags.quality),
+    rasterDpi: flags.rasterDpi ? Number(flags.rasterDpi) : void 0,
+    maxDimension: Number(flags.maxDimension),
+    baseUrl: flags.baseUrl ? String(flags.baseUrl) : void 0,
+    storage
+  };
+  const result = type === "pdf" ? await ingestPdf({
+    ...common,
+    input: String(input),
+    page: Number(flags.page)
+  }) : await ingestImage({
+    ...common,
+    input: String(input)
+  });
+  process.stdout.write(`${JSON.stringify(result.manifest, null, 2)}
+`);
+});
+cli.help();
+cli.parse();
+function inferType(input) {
+  return /\.pdf$/i.test(input) ? "pdf" : "image";
+}
+async function loadCustomAdapter(modulePath, exportName) {
+  const mod = await import(resolve(modulePath));
+  const candidate = mod[exportName];
+  if (typeof candidate === "function") {
+    return candidate();
+  }
+  if (candidate && typeof candidate === "object") {
+    return candidate;
+  }
+  throw new Error(`Unable to load storage adapter export "${exportName}" from ${modulePath}`);
+}
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map