@ericchen1990/pano-view 3.4.2 → 3.6.0

package/dist/data.mjs

@@ -0,0 +1,1057 @@
+// src/data/errors.ts
+var PanoDataError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "PanoDataError";
+    this.code = code;
+    Object.assign(this, details);
+  }
+};
+function aborted(signal) {
+  if (signal?.aborted)
+    throw new PanoDataError("ABORTED", "Loading was cancelled");
+}
+
+// ../../shared/viewer-config.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`${field}: expected a nonempty string`);
+  return value;
+}
+function positive(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+    throw new Error(`${field}: expected a positive safe integer`);
+  return value;
+}
+function validateViewerConfig(value) {
+  if (!isRecord(value)) throw new Error("viewerConfig: expected an object");
+  if (value.type !== "tile" && value.type !== "sphereTile")
+    throw new Error("type: expected tile or sphereTile");
+  if (!isRecord(value.multires))
+    throw new Error("multires: expected an object");
+  const tileSize = positive(value.multires.tileSize, "multires.tileSize");
+  if (tileSize > 8192) throw new Error("multires.tileSize: maximum is 8192");
+  const input = value.multires.levels;
+  if (!Array.isArray(input) || input.length === 0 || input.length > 64)
+    throw new Error("multires.levels: expected 1 to 64 levels");
+  const urlTemplate = requiredString(value.urlTemplate, "urlTemplate");
+  const previewUrl = requiredString(value.previewUrl, "previewUrl");
+  if (/%/.test(urlTemplate.replace(/%s|%l|%0*[hxucvywr]/g, "")))
+    throw new Error("urlTemplate: unsupported placeholder");
+  if (value.type === "tile") {
+    const levels2 = input.map(
+      (level, i) => positive(level, `multires.levels[${i}]`)
+    );
+    if (levels2.some((level, i) => i > 0 && level <= levels2[i - 1]))
+      throw new Error("multires.levels: face sizes must increase");
+    const order = value.previewFaceOrder;
+    if (!Array.isArray(order) || order.length !== 6 || !["f", "r", "b", "l", "u", "d"].every((face) => order.includes(face)))
+      throw new Error("previewFaceOrder: expected six unique cube faces");
+    return {
+      type: "tile",
+      multires: { tileSize, levels: levels2 },
+      urlTemplate,
+      previewUrl,
+      previewFaceOrder: [...order]
+    };
+  }
+  if (urlTemplate.includes("%s"))
+    throw new Error("urlTemplate: sphere has no cube face");
+  if (value.indexBase !== 0 && value.indexBase !== 1)
+    throw new Error("indexBase: expected 0 or 1");
+  const levels = input.map((level, i) => {
+    if (!isRecord(level))
+      throw new Error(`multires.levels[${i}]: expected dimensions`);
+    const width = positive(level.width, `multires.levels[${i}].width`);
+    const height = positive(level.height, `multires.levels[${i}].height`);
+    if (Math.abs(width - 2 * height) > 2)
+      throw new Error(`multires.levels[${i}]: expected a full 2:1 panorama`);
+    return { width, height };
+  });
+  if (levels.some(
+    (level, i) => i > 0 && (level.width <= levels[i - 1].width || level.height <= levels[i - 1].height)
+  ))
+    throw new Error("multires.levels: dimensions must increase");
+  return {
+    type: "sphereTile",
+    multires: { tileSize, levels },
+    urlTemplate,
+    previewUrl,
+    indexBase: value.indexBase
+  };
+}
+
+// src/tile/multires.ts
+function resolveTemplateUrl(template, address) {
+  return template.replace(/%s/g, address.face).replace(/%l/g, String(address.level)).replace(/%(0*)([hxucvywr])/g, (_match, zeroes, placeholder) => {
+    const value = "hxuc".includes(placeholder) ? address.col : address.row;
+    return String(value).padStart(zeroes.length + 1, "0");
+  });
+}
+
+// src/data/viewer.ts
+function documentUrl(input) {
+  try {
+    const url = new URL(
+      input,
+      typeof document === "undefined" ? void 0 : document.baseURI
+    );
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      throw new Error("Use HTTP(S)");
+    return url.href;
+  } catch (cause) {
+    throw new PanoDataError(
+      "INVALID_OPTIONS",
+      "Expected an HTTP(S) URL; Node.js requires an absolute URL",
+      { cause }
+    );
+  }
+}
+function directoryUrl(input) {
+  const url = new URL(input);
+  url.search = "";
+  url.hash = "";
+  if (!url.pathname.endsWith("/")) url.pathname += "/";
+  return url.href;
+}
+function resolveResource(baseUrl, path) {
+  try {
+    const url = new URL(path, directoryUrl(baseUrl));
+    if (!["http:", "https:", "blob:", "data:"].includes(url.protocol))
+      throw new Error("Unsupported resource URL protocol");
+    return url.href;
+  } catch (cause) {
+    throw new PanoDataError(
+      "INVALID_CONFIG",
+      `Invalid resource path: ${path}`,
+      { cause }
+    );
+  }
+}
+function mapResource(path, context, resolver) {
+  let result;
+  try {
+    result = resolver ? resolver(path, context) : context.defaultUrl;
+  } catch (cause) {
+    throw new PanoDataError("INVALID_CONFIG", "resolveAssetUrl failed", {
+      sceneId: context.sceneId,
+      cause
+    });
+  }
+  if (typeof result !== "string" || !result.trim())
+    throw new PanoDataError(
+      "INVALID_CONFIG",
+      "resolveAssetUrl must return a nonempty final URL",
+      { sceneId: context.sceneId }
+    );
+  if (!result.startsWith("/") && !/^(https?:|blob:|data:)/i.test(result))
+    throw new PanoDataError(
+      "INVALID_CONFIG",
+      "resolveAssetUrl must return an absolute URL or a site-root path",
+      { sceneId: context.sceneId }
+    );
+  return result;
+}
+function parseConfig(value) {
+  if (isRecord(value) && value.type !== "tile" && value.type !== "sphereTile")
+    throw new PanoDataError(
+      "UNSUPPORTED_PROJECTION",
+      "Expected a tile or sphereTile configuration",
+      { field: "type" }
+    );
+  try {
+    return validateViewerConfig(value);
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : "Invalid viewer configuration";
+    throw new PanoDataError("INVALID_CONFIG", message, {
+      cause,
+      field: message.split(":")[0]
+    });
+  }
+}
+function sceneFromViewerConfig(value, options) {
+  if (!options || typeof options.id !== "string" || !options.id.trim() || typeof options.baseUrl !== "string" || !options.baseUrl.trim())
+    throw new PanoDataError("INVALID_OPTIONS", "id and baseUrl are required");
+  const config = parseConfig(value);
+  const baseUrl = directoryUrl(documentUrl(options.baseUrl));
+  const resolve = (path, kind) => mapResource(
+    path,
+    {
+      kind,
+      sceneId: options.id,
+      defaultUrl: resolveResource(baseUrl, path)
+    },
+    options.resolveAssetUrl
+  );
+  const previewUrl = resolve(config.previewUrl, "preview");
+  if (config.type === "tile") {
+    return {
+      ...config,
+      id: options.id,
+      baseUrl,
+      previewUrl,
+      ...options.resolveAssetUrl ? {
+        resolveTileUrl: (address) => resolve(resolveTemplateUrl(config.urlTemplate, address), "tile")
+      } : {}
+    };
+  }
+  return {
+    ...config,
+    id: options.id,
+    baseUrl,
+    previewUrl,
+    ...options.resolveAssetUrl ? {
+      resolveTileUrl: (address) => {
+        const path = resolveTemplateUrl(config.urlTemplate, {
+          face: "f",
+          level: address.level + config.indexBase,
+          row: address.row + config.indexBase,
+          col: address.col + config.indexBase
+        });
+        return resolve(path, "tile");
+      }
+    } : {}
+  };
+}
+async function readJson(url, options) {
+  const signal = options.requestInit?.signal;
+  aborted(signal);
+  let response;
+  try {
+    response = await fetch(url, { ...options.requestInit, method: "GET" });
+  } catch (cause) {
+    aborted(signal);
+    throw new PanoDataError(
+      "FETCH_FAILED",
+      "Could not fetch JSON; check the network and server CORS settings",
+      { cause }
+    );
+  }
+  aborted(signal);
+  if (!response.ok)
+    throw new PanoDataError(
+      "HTTP_ERROR",
+      `JSON request returned HTTP ${response.status}`,
+      { status: response.status }
+    );
+  try {
+    const value = await response.json();
+    aborted(signal);
+    return { value, url: response.url || url };
+  } catch (cause) {
+    aborted(signal);
+    throw new PanoDataError(
+      "INVALID_JSON",
+      "Expected JSON; check for an HTML fallback or login page",
+      { cause }
+    );
+  }
+}
+async function loadSceneFromJson(url, options) {
+  if (!options || typeof options.id !== "string" || !options.id.trim())
+    throw new PanoDataError("INVALID_OPTIONS", "id is required");
+  const response = await readJson(documentUrl(url), options);
+  if (!isRecord(response.value))
+    throw new PanoDataError(
+      "INVALID_CONFIG",
+      "viewer.json must contain an object"
+    );
+  if (response.value.schemaVersion !== 1)
+    throw new PanoDataError(
+      "UNSUPPORTED_SCHEMA_VERSION",
+      "Unsupported viewer.json schemaVersion",
+      { field: "schemaVersion" }
+    );
+  return sceneFromViewerConfig(response.value, {
+    ...options,
+    baseUrl: options.baseUrl ?? new URL(".", response.url).href
+  });
+}
+
+// src/view-limits.ts
+function parseViewLimits(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("viewLimits: expected an object");
+  const result = {};
+  for (const axis of ["yaw", "pitch", "fov"]) {
+    const input = value[axis];
+    if (input === void 0) continue;
+    if (!input || typeof input !== "object" || Array.isArray(input))
+      throw new Error(`viewLimits.${axis}: expected min and max`);
+    const { min, max } = input;
+    const lower = axis === "yaw" ? -180 : axis === "pitch" ? -90 : 1;
+    const upper = axis === "yaw" ? 180 : axis === "pitch" ? 90 : 179;
+    if (typeof min !== "number" || typeof max !== "number" || !Number.isFinite(min) || !Number.isFinite(max) || min < lower || min > upper || max < lower || max > upper)
+      throw new Error(`viewLimits.${axis}: expected finite min and max from ${lower} to ${upper}`);
+    if (axis !== "yaw" && min > max)
+      throw new Error(`viewLimits.${axis}: min must not exceed max`);
+    result[axis] = { min, max };
+  }
+  return result;
+}
+
+// src/data/popups.ts
+function parsePopups(value, draft = false) {
+  if (value === void 0) return void 0;
+  try {
+    if (!Array.isArray(value)) throw new Error("popups: expected an array");
+    const ids = /* @__PURE__ */ new Set();
+    const string = (input, field, allowEmpty = false) => {
+      if (typeof input !== "string" || !allowEmpty && !input.trim())
+        throw new Error(`${field}: expected a ${allowEmpty ? "string" : "nonempty string"}`);
+      return input;
+    };
+    return value.map((entry, index) => {
+      const field = `popups[${index}]`;
+      if (!isRecord(entry)) throw new Error(`${field}: expected an object`);
+      const id = requiredString(entry.id, `${field}.id`);
+      if (ids.has(id)) throw new Error(`${field}.id: duplicate popup ID`);
+      ids.add(id);
+      const title = string(entry.title, `${field}.title`, draft);
+      if (!Array.isArray(entry.blocks)) throw new Error(`${field}.blocks: expected an array`);
+      const blockIds = /* @__PURE__ */ new Set();
+      const blocks = entry.blocks.map((block, i) => {
+        const path = `${field}.blocks[${i}]`;
+        if (!isRecord(block)) throw new Error(`${path}: expected an object`);
+        const id2 = requiredString(block.id, `${path}.id`);
+        if (blockIds.has(id2)) throw new Error(`${path}.id: duplicate block ID`);
+        blockIds.add(id2);
+        if (block.type === "text") return { id: id2, type: "text", text: string(block.text, `${path}.text`, true) };
+        const src = string(block.src, `${path}.src`, draft);
+        if (src) resolveResource("https://popup.invalid/", src);
+        if (block.type === "image") return {
+          id: id2,
+          type: "image",
+          src,
+          ...block.alt === void 0 ? {} : { alt: string(block.alt, `${path}.alt`, true) }
+        };
+        if (block.type === "audio") return { id: id2, type: "audio", src };
+        if (block.type === "video") {
+          const poster = block.poster === void 0 ? void 0 : string(block.poster, `${path}.poster`, true);
+          if (poster) resolveResource("https://popup.invalid/", poster);
+          return { id: id2, type: "video", src, ...poster ? { poster } : {} };
+        }
+        throw new Error(`${path}.type: unsupported content block`);
+      });
+      return { id, title, blocks };
+    });
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : "Invalid popup content";
+    throw new PanoDataError("INVALID_PROJECT", message, { field: message.split(":")[0], cause });
+  }
+}
+function resolveProjectPopupAssets(popup, baseUrl, resolver) {
+  return { ...popup, blocks: popup.blocks.map((block) => {
+    if (block.type === "text") return { ...block };
+    const resolve = (path, field) => {
+      if (!path) throw new PanoDataError("INVALID_PROJECT", `${popup.id}/${block.id}.${field}: choose a resource`);
+      const context = { defaultUrl: resolveResource(baseUrl, path), popupId: popup.id, blockId: block.id, field };
+      const result = resolver ? resolver(path, context) : context.defaultUrl;
+      if (typeof result !== "string" || !result.startsWith("/") && !/^(https?:|blob:|data:)/i.test(result))
+        throw new PanoDataError("INVALID_CONFIG", "resolvePopupAssetUrl must return an absolute URL or a site-root path");
+      return result;
+    };
+    return { ...block, src: resolve(block.src, "src"), ...block.type === "video" && block.poster ? { poster: resolve(block.poster, "poster") } : {} };
+  }) };
+}
+
+// ../../shared/cursor-assets.ts
+function mapCursorAssets(cursor, resolve) {
+  return cursor.replace(
+    /url\(\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|((?:\\.|[^)\\])*?))\s*\)/gi,
+    (_match, double, single, bare) => {
+      const path = (double ?? single ?? bare ?? "").replace(
+        /\\([\da-f]{1,6}\s?|.)/gi,
+        (_escape, value) => /^[\da-f]/i.test(value) ? String.fromCodePoint(
+          Math.min(parseInt(value.trim(), 16), 1114111)
+        ) : value
+      );
+      return `url(${JSON.stringify(resolve(path))})`;
+    }
+  );
+}
+
+// src/data/hotspots.ts
+var projectHotspotTriggers = ["click", "pointerenter", "pointerleave"];
+function hotspotAction(hotspot, trigger) {
+  return hotspot.events?.[trigger] ?? (trigger === "click" ? hotspot.action : void 0);
+}
+function setHotspotAction(hotspot, trigger, action) {
+  const events = { ...hotspot.events };
+  const next = { ...hotspot, events };
+  if (trigger === "click") delete next.action;
+  if (action) events[trigger] = action;
+  else delete events[trigger];
+  if (!Object.keys(events).length) delete next.events;
+  return next;
+}
+function jsonValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "object" || !value || seen.has(value)) throw new Error("params: expected JSON data");
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new Error("params: expected JSON data");
+  seen.add(value);
+  const result = Array.isArray(value) ? value.map((item) => jsonValue(item, seen)) : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonValue(item, seen)]));
+  seen.delete(value);
+  return result;
+}
+function parseAction(action) {
+  if (!isRecord(action)) throw new Error("action: expected an object");
+  if (action.type === "scene") return { type: "scene", sceneId: requiredString(action.sceneId, "action.sceneId") };
+  if (action.type === "popup") return { type: "popup", popupId: requiredString(action.popupId, "action.popupId") };
+  if (action.type === "custom") {
+    if (action.params !== void 0 && (!isRecord(action.params) || Array.isArray(action.params))) throw new Error("action.params: expected an object");
+    return { type: "custom", actionId: requiredString(action.actionId, "action.actionId"), ...action.params === void 0 ? {} : { params: jsonValue(action.params) } };
+  }
+  if (action.type === "view") {
+    const position = parsePosition(action.view, "action.view");
+    const fov = finite(action.view.fov, "action.view.fov");
+    if (fov <= 0 || fov >= 180) throw new Error("action.view.fov: expected 0 < fov < 180");
+    const duration = action.duration === void 0 ? void 0 : finite(action.duration, "action.duration");
+    if (duration !== void 0 && duration < 0) throw new Error("action.duration: expected a nonnegative number");
+    return { type: "view", view: { ...position, fov }, ...duration === void 0 ? {} : { duration } };
+  }
+  throw new Error("action.type: unsupported action");
+}
+var common = [
+  "label",
+  "visible",
+  "interactive",
+  "pointerEvents",
+  "cursor",
+  "renderOrder",
+  "tooltip",
+  "tooltipTrigger",
+  "tooltipPlacement",
+  "tooltipOffset",
+  "tooltipAppearance"
+];
+var point = [
+  "position",
+  "width",
+  "height",
+  "scale",
+  "mode",
+  "distance",
+  "scaleMode",
+  "referenceFov",
+  "rotation",
+  "opacity"
+];
+var fields = {
+  image: ["src"],
+  graphic: ["graphic"],
+  sequence: ["src", "frameCount", "frameDirection", "playing", "fps", "loop"],
+  video: [
+    "src",
+    "poster",
+    "playing",
+    "loop",
+    "muted",
+    "volume",
+    "playsInline",
+    "preload",
+    "crossOrigin"
+  ],
+  audio: [
+    "src",
+    "format",
+    "playing",
+    "loop",
+    "muted",
+    "volume",
+    "pauseWhenHidden",
+    "range",
+    "icon",
+    "playingIcon",
+    "marker",
+    "crossOrigin"
+  ],
+  text: [
+    "text",
+    "fontFamily",
+    "fontSize",
+    "fontWeight",
+    "fontStyle",
+    "color",
+    "background",
+    "backgroundOpacity",
+    "padding",
+    "align",
+    "verticalAlign",
+    "whiteSpace",
+    "lineHeight",
+    "borderRadius",
+    "stroke",
+    "strokeWidth"
+  ],
+  iframe: [
+    "src",
+    "title",
+    "sandbox",
+    "allow",
+    "referrerPolicy",
+    "loading",
+    "pointerPolicy",
+    "background"
+  ],
+  polygon: [
+    "vertices",
+    "fill",
+    "fillOpacity",
+    "stroke",
+    "strokeWidth",
+    "strokeOpacity",
+    "strokeDashSize",
+    "strokeGapSize"
+  ],
+  polyline: [
+    "vertices",
+    "stroke",
+    "strokeWidth",
+    "strokeOpacity",
+    "strokeDashSize",
+    "strokeGapSize"
+  ]
+};
+var booleanFields = /* @__PURE__ */ new Set([
+  "visible",
+  "interactive",
+  "playing",
+  "loop",
+  "muted",
+  "playsInline",
+  "pauseWhenHidden",
+  "marker"
+]);
+var numberFields = /* @__PURE__ */ new Set([
+  "renderOrder",
+  "tooltipOffset",
+  "width",
+  "height",
+  "scale",
+  "distance",
+  "referenceFov",
+  "rotation",
+  "opacity",
+  "frameCount",
+  "fps",
+  "volume",
+  "range",
+  "fontSize",
+  "backgroundOpacity",
+  "padding",
+  "lineHeight",
+  "borderRadius",
+  "strokeWidth",
+  "fillOpacity",
+  "strokeOpacity",
+  "strokeDashSize",
+  "strokeGapSize"
+]);
+var positiveFields = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "scale",
+  "distance",
+  "referenceFov",
+  "frameCount",
+  "fps",
+  "fontSize",
+  "lineHeight"
+]);
+var enums = {
+  pointerEvents: ["auto", "none"],
+  tooltipTrigger: ["always", "hover", "click"],
+  tooltipPlacement: ["top", "bottom", "left", "right"],
+  mode: ["surface", "billboard"],
+  scaleMode: ["fov", "fixed"],
+  frameDirection: ["horizontal", "vertical"],
+  preload: ["none", "metadata", "auto"],
+  crossOrigin: ["", "anonymous", "use-credentials"],
+  fontStyle: ["normal", "italic"],
+  align: ["left", "center", "right"],
+  verticalAlign: ["top", "middle", "bottom"],
+  whiteSpace: ["normal", "nowrap"],
+  loading: ["eager", "lazy"],
+  pointerPolicy: ["hotspot", "content"],
+  referrerPolicy: [
+    "",
+    "no-referrer",
+    "no-referrer-when-downgrade",
+    "origin",
+    "origin-when-cross-origin",
+    "same-origin",
+    "strict-origin",
+    "strict-origin-when-cross-origin",
+    "unsafe-url"
+  ]
+};
+function finite(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new Error(`${field}: expected a finite number`);
+  return value;
+}
+function parsePosition(value, field) {
+  if (!isRecord(value)) throw new Error(`${field}: expected yaw and pitch`);
+  const yaw = finite(value.yaw, `${field}.yaw`);
+  const pitch = finite(value.pitch, `${field}.pitch`);
+  if (Math.abs(pitch) > 90)
+    throw new Error(`${field}.pitch: expected -90 to 90`);
+  return { yaw, pitch };
+}
+function parseGraphic(value) {
+  if (!isRecord(value)) throw new Error("graphic: expected an object");
+  const kind = requiredString(value.kind, "graphic.kind");
+  if (![
+    "circle",
+    "triangle",
+    "diamond",
+    "star",
+    "arrow",
+    "rectangle",
+    "ring",
+    "svg",
+    "path"
+  ].includes(kind))
+    throw new Error("graphic.kind: unsupported graphic");
+  const result = { kind };
+  for (const key of ["fill", "stroke"]) {
+    if (value[key] !== void 0)
+      result[key] = requiredString(value[key], `graphic.${key}`);
+  }
+  for (const key of ["strokeWidth", "cornerRadius", "innerRadius"]) {
+    if (value[key] !== void 0)
+      result[key] = finite(value[key], `graphic.${key}`);
+  }
+  if (kind === "svg") result.src = requiredString(value.src, "graphic.src");
+  if (kind === "path") {
+    result.path = requiredString(value.path, "graphic.path");
+    if (!Array.isArray(value.viewBox) || value.viewBox.length !== 4)
+      throw new Error("graphic.viewBox: expected four numbers");
+    const viewBox = value.viewBox.map(
+      (n, i) => finite(n, `graphic.viewBox[${i}]`)
+    );
+    if (viewBox[2] <= 0 || viewBox[3] <= 0)
+      throw new Error("graphic.viewBox: width and height must be positive");
+    result.viewBox = viewBox;
+  }
+  return result;
+}
+function parseTooltip(value) {
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) throw new Error("tooltip: expected text or an object");
+  const result = {};
+  for (const key of ["text", "image", "imageAlt"]) {
+    if (value[key] !== void 0) {
+      if (typeof value[key] !== "string")
+        throw new Error(`tooltip.${key}: expected a string`);
+      result[key] = value[key];
+    }
+  }
+  return result;
+}
+function parseAppearance(value) {
+  if (!isRecord(value))
+    throw new Error("tooltipAppearance: expected an object");
+  const result = {};
+  for (const key of [
+    "background",
+    "color",
+    "border",
+    "borderRadius",
+    "shadow",
+    "padding",
+    "fontSize",
+    "fontFamily",
+    "lineHeight",
+    "letterSpacing"
+  ]) {
+    const item = value[key];
+    if (item === void 0) continue;
+    if (["background", "color", "border", "shadow", "fontFamily"].includes(key) && typeof item !== "string")
+      throw new Error(`tooltipAppearance.${key}: expected a string`);
+    if (typeof item !== "string" && (typeof item !== "number" || !Number.isFinite(item)))
+      throw new Error(
+        `tooltipAppearance.${key}: expected a string or finite number`
+      );
+    result[key] = item;
+  }
+  return result;
+}
+function parseHotspot(value, sceneId, field) {
+  try {
+    if (!isRecord(value)) throw new Error("expected a hotspot object");
+    const type = requiredString(value.type, "type");
+    if (!Object.prototype.hasOwnProperty.call(fields, type))
+      throw new Error("type: unsupported hotspot type");
+    const kind = type;
+    const result = {
+      type,
+      id: requiredString(value.id, "id")
+    };
+    const isPath = kind === "polygon" || kind === "polyline";
+    const allowed = [...common, ...isPath ? [] : point, ...fields[kind]];
+    for (const key of allowed) {
+      const item = value[key];
+      if (item === void 0) continue;
+      if (key === "position") result[key] = parsePosition(item, key);
+      else if (key === "vertices") {
+        if (!Array.isArray(item) || item.length < (kind === "polygon" ? 3 : 2))
+          throw new Error("vertices: not enough points");
+        result[key] = item.map((p, i) => parsePosition(p, `vertices[${i}]`));
+      } else if (key === "graphic") result[key] = parseGraphic(item);
+      else if (key === "tooltip") result[key] = parseTooltip(item);
+      else if (key === "tooltipAppearance") result[key] = parseAppearance(item);
+      else if (booleanFields.has(key)) {
+        if (typeof item !== "boolean")
+          throw new Error(`${key}: expected a boolean`);
+        result[key] = item;
+      } else if (numberFields.has(key)) {
+        const n = finite(item, key);
+        if (positiveFields.has(key) && n <= 0)
+          throw new Error(`${key}: expected a positive number`);
+        if (key === "frameCount" && !Number.isSafeInteger(n))
+          throw new Error("frameCount: expected an integer");
+        if ([
+          "opacity",
+          "fillOpacity",
+          "strokeOpacity",
+          "volume",
+          "backgroundOpacity"
+        ].includes(key) && (n < 0 || n > 1))
+          throw new Error(`${key}: expected 0 to 1`);
+        result[key] = n;
+      } else if (key === "fontWeight" && typeof item === "number")
+        result[key] = finite(item, key);
+      else if ((key === "src" || key === "format") && kind === "audio" && Array.isArray(item)) {
+        if (!item.length)
+          throw new Error(`${key}: expected audio ${key === "src" ? "sources" : "formats"}`);
+        result[key] = item.map((entry, i) => requiredString(entry, `${key}[${i}]`));
+      } else {
+        if (typeof item !== "string")
+          throw new Error(`${key}: expected a string`);
+        if (enums[key] && !enums[key].includes(item))
+          throw new Error(`${key}: unsupported value`);
+        result[key] = item;
+      }
+    }
+    if (!isPath && !result.position) throw new Error("position: required");
+    if (isPath && !result.vertices) throw new Error("vertices: required");
+    if (["image", "sequence", "video", "audio", "iframe"].includes(kind) && !(typeof result.src === "string" ? result.src.trim() : Array.isArray(result.src)))
+      throw new Error("src: required");
+    if (kind === "graphic" && !result.graphic)
+      throw new Error("graphic: required");
+    if (kind === "text" && typeof result.text !== "string")
+      throw new Error("text: required");
+    if (kind === "sequence" && !result.frameCount)
+      throw new Error("frameCount: required");
+    if (value.action !== void 0) result.action = parseAction(value.action);
+    if (value.events !== void 0) {
+      if (!isRecord(value.events)) throw new Error("events: expected an object");
+      const events = {};
+      for (const key of Object.keys(value.events)) {
+        if (!projectHotspotTriggers.includes(key)) throw new Error(`events.${key}: unsupported trigger`);
+        try {
+          events[key] = parseAction(value.events[key]);
+        } catch (error) {
+          throw new Error(`events.${key}.${error instanceof Error ? error.message : "invalid action"}`);
+        }
+      }
+      result.events = events;
+    }
+    return result;
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : "Invalid hotspot";
+    throw new PanoDataError("INVALID_PROJECT", `${field}.${detail}`, {
+      sceneId,
+      field: `${field}.${detail.split(":")[0]}`,
+      cause
+    });
+  }
+}
+function resolveHotspotAssets(hotspot, baseUrl, sceneId, resolver) {
+  const resolve = (path) => path ? mapResource(
+    path,
+    {
+      kind: "hotspot",
+      sceneId,
+      hotspotId: hotspot.id,
+      defaultUrl: resolveResource(baseUrl, path)
+    },
+    resolver
+  ) : path;
+  const result = { ...hotspot };
+  if (result.cursor) result.cursor = mapCursorAssets(result.cursor, resolve);
+  if (result.tooltipAppearance?.background) result.tooltipAppearance = {
+    ...result.tooltipAppearance,
+    background: mapCursorAssets(result.tooltipAppearance.background, resolve)
+  };
+  if ("src" in result)
+    result.src = Array.isArray(result.src) ? result.src.map(resolve) : resolve(result.src);
+  if ("poster" in result && result.poster)
+    result.poster = resolve(result.poster);
+  if (result.type === "audio") {
+    if (result.icon) result.icon = resolve(result.icon);
+    if (result.playingIcon) result.playingIcon = resolve(result.playingIcon);
+  }
+  if (result.type === "graphic" && result.graphic.kind === "svg")
+    result.graphic = { ...result.graphic, src: resolve(result.graphic.src) };
+  if (typeof result.tooltip === "object")
+    result.tooltip = {
+      ...result.tooltip,
+      ...result.tooltip.image ? { image: resolve(result.tooltip.image) } : {}
+    };
+  return result;
+}
+
+// src/data/project.ts
+function optionalString(record, key) {
+  return record[key] === void 0 ? void 0 : requiredString(record[key], key);
+}
+function parsePanoProject(value, options = {}) {
+  if (!isRecord(value))
+    throw new PanoDataError("INVALID_PROJECT", "Expected a project object");
+  if (value.schemaVersion !== 1)
+    throw new PanoDataError(
+      "UNSUPPORTED_SCHEMA_VERSION",
+      "Unsupported project schemaVersion",
+      { field: "schemaVersion" }
+    );
+  try {
+    const popups = parsePopups(value.popups, options.draft);
+    if (!Array.isArray(value.scenes) || !options.draft && !value.scenes.length)
+      throw new Error("scenes: expected a nonempty array");
+    const ids = /* @__PURE__ */ new Set();
+    const scenes = value.scenes.map(
+      (entry, index) => {
+        let id;
+        const field = `scenes[${index}]`;
+        try {
+          if (!isRecord(entry)) throw new Error("expected a scene object");
+          id = requiredString(entry.id, "id");
+          if (ids.has(id)) throw new Error("id: duplicate scene ID");
+          ids.add(id);
+          if (!isRecord(entry.source))
+            throw new Error("source: expected an object");
+          const src = entry.source;
+          if (src.viewerUrl !== void 0 === (src.viewerConfig !== void 0))
+            throw new Error(
+              "source: provide exactly one of viewerUrl or viewerConfig"
+            );
+          const baseUrl = optionalString(src, "baseUrl");
+          const source = src.viewerUrl !== void 0 ? {
+            viewerUrl: requiredString(src.viewerUrl, "source.viewerUrl"),
+            baseUrl
+          } : { viewerConfig: parseConfig(src.viewerConfig), baseUrl };
+          const viewLimits = parseViewLimits(entry.viewLimits);
+          let initialView;
+          if (entry.initialView !== void 0) {
+            if (!isRecord(entry.initialView))
+              throw new Error("initialView: expected an object");
+            const input = entry.initialView;
+            const position = parsePosition(
+              { yaw: input.yaw ?? 0, pitch: input.pitch ?? 0 },
+              "initialView"
+            );
+            const fov = input.fov ?? 75;
+            if (typeof fov !== "number" || !Number.isFinite(fov) || fov <= 0 || fov >= 180)
+              throw new Error(
+                "initialView.fov: expected a number between 0 and 180"
+              );
+            initialView = { ...position, fov };
+          }
+          if (entry.hotspots !== void 0 && !Array.isArray(entry.hotspots))
+            throw new Error("hotspots: expected an array");
+          const hotspotIds = /* @__PURE__ */ new Set();
+          const hotspots = (entry.hotspots ?? []).map(
+            (hotspot, i) => {
+              const result = parseHotspot(
+                hotspot,
+                id,
+                `${field}.hotspots[${i}]`
+              );
+              if (hotspotIds.has(result.id))
+                throw new Error(`hotspots[${i}].id: duplicate hotspot ID`);
+              hotspotIds.add(result.id);
+              return result;
+            }
+          );
+          return {
+            id,
+            title: optionalString(entry, "title"),
+            source,
+            initialView,
+            ...viewLimits === void 0 ? {} : { viewLimits },
+            hotspots
+          };
+        } catch (cause) {
+          if (cause instanceof PanoDataError && cause.sceneId) throw cause;
+          const detail = cause instanceof Error ? cause.message : "Invalid scene";
+          throw new PanoDataError(
+            cause instanceof PanoDataError ? cause.code : "INVALID_PROJECT",
+            `${field}.${detail}`,
+            {
+              sceneId: id,
+              field: `${field}.${cause instanceof PanoDataError ? `source.viewerConfig.${cause.field ?? ""}` : detail.split(":")[0]}`,
+              cause
+            }
+          );
+        }
+      }
+    );
+    const initialSceneId = optionalString(value, "initialSceneId") ?? scenes[0]?.id;
+    if (initialSceneId !== void 0 && !ids.has(initialSceneId))
+      throw new PanoDataError(
+        "INVALID_REFERENCE",
+        "initialSceneId: scene does not exist",
+        { field: "initialSceneId" }
+      );
+    for (const [index, scene] of scenes.entries()) {
+      for (const [i, hotspot] of (scene.hotspots ?? []).entries()) {
+        for (const trigger of projectHotspotTriggers) {
+          const action = hotspotAction(hotspot, trigger);
+          if (action?.type === "popup" && !popups?.some((popup) => popup.id === action.popupId))
+            throw new PanoDataError("INVALID_REFERENCE", "Hotspot target popup does not exist", {
+              sceneId: scene.id,
+              field: `scenes[${index}].hotspots[${i}].${hotspot.events?.[trigger] ? `events.${trigger}` : "action"}.popupId`
+            });
+          if (action?.type === "scene" && !ids.has(action.sceneId))
+            throw new PanoDataError(
+              "INVALID_REFERENCE",
+              "Hotspot target scene does not exist",
+              {
+                sceneId: scene.id,
+                field: `scenes[${index}].hotspots[${i}].${hotspot.events?.[trigger] ? `events.${trigger}` : "action"}.sceneId`
+              }
+            );
+        }
+      }
+    }
+    return {
+      schemaVersion: 1,
+      title: optionalString(value, "title"),
+      initialSceneId,
+      scenes,
+      ...popups === void 0 ? {} : { popups }
+    };
+  } catch (cause) {
+    if (cause instanceof PanoDataError) throw cause;
+    const message = cause instanceof Error ? cause.message : "Invalid project";
+    throw new PanoDataError("INVALID_PROJECT", message, {
+      cause,
+      field: message.split(":")[0]
+    });
+  }
+}
+async function loadPanoProject(source, options = {}) {
+  aborted(options.requestInit?.signal);
+  let definition;
+  let baseUrl;
+  if (typeof source === "string") {
+    const response = await readJson(documentUrl(source), options);
+    definition = parsePanoProject(response.value);
+    baseUrl = options.baseUrl ?? new URL(".", response.url).href;
+  } else {
+    if (!options.baseUrl)
+      throw new PanoDataError(
+        "INVALID_OPTIONS",
+        "baseUrl is required for project object input"
+      );
+    definition = parsePanoProject(source);
+    baseUrl = options.baseUrl;
+  }
+  const root = directoryUrl(documentUrl(baseUrl));
+  const controller = new AbortController();
+  const signal = options.requestInit?.signal;
+  const cancel = () => controller.abort();
+  signal?.addEventListener("abort", cancel, { once: true });
+  const scenes = new Array(definition.scenes.length);
+  let next = 0;
+  let failure;
+  async function worker() {
+    while (next < definition.scenes.length && !controller.signal.aborted) {
+      const index = next++;
+      const item = definition.scenes[index];
+      try {
+        const sourceBase = item.source.baseUrl === void 0 ? void 0 : resolveResource(root, item.source.baseUrl);
+        const sceneOptions = {
+          id: item.id,
+          resolveAssetUrl: options.resolveAssetUrl
+        };
+        const scene = item.source.viewerUrl !== void 0 ? await loadSceneFromJson(
+          resolveResource(root, item.source.viewerUrl),
+          {
+            ...sceneOptions,
+            baseUrl: sourceBase,
+            requestInit: {
+              ...options.requestInit,
+              signal: controller.signal
+            }
+          }
+        ) : sceneFromViewerConfig(item.source.viewerConfig, {
+          ...sceneOptions,
+          baseUrl: sourceBase ?? root
+        });
+        aborted(controller.signal);
+        if (item.viewLimits !== void 0) scene.viewLimits = item.viewLimits;
+        scenes[index] = {
+          scene,
+          title: item.title,
+          initialView: item.initialView ? { yaw: 0, pitch: 0, fov: 75, ...item.initialView } : void 0,
+          hotspots: item.hotspots.map(
+            (h) => resolveHotspotAssets(h, root, item.id, options.resolveAssetUrl)
+          )
+        };
+      } catch (cause) {
+        if (!failure) {
+          const error = cause instanceof PanoDataError ? cause : new PanoDataError(
+            "INVALID_CONFIG",
+            cause instanceof Error ? cause.message : "Could not load scene",
+            { cause }
+          );
+          const field = `scenes[${index}].${error.field ?? (item.source.viewerUrl !== void 0 ? "source.viewerUrl" : "source.viewerConfig")}`;
+          failure = new PanoDataError(
+            error.code,
+            `Scene ${item.id}: ${error.message}`,
+            { status: error.status, sceneId: item.id, field, cause: error }
+          );
+        }
+        controller.abort();
+      }
+    }
+  }
+  try {
+    aborted(signal);
+    await Promise.all(
+      Array.from({ length: Math.min(4, scenes.length) }, worker)
+    );
+    aborted(signal);
+    if (failure) throw failure;
+    return {
+      title: definition.title,
+      initialSceneId: definition.initialSceneId,
+      scenes,
+      ...definition.popups === void 0 ? {} : { popups: definition.popups.map((popup) => resolveProjectPopupAssets(popup, root, options.resolvePopupAssetUrl)) }
+    };
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+  }
+}
+export {
+  PanoDataError,
+  hotspotAction,
+  loadPanoProject,
+  loadSceneFromJson,
+  parsePanoProject,
+  projectHotspotTriggers,
+  resolveHotspotAssets as resolveProjectHotspotAssets,
+  resolveProjectPopupAssets,
+  sceneFromViewerConfig,
+  setHotspotAction
+};
+//# sourceMappingURL=data.mjs.map