@oicl/openbridge-webcomponents 2.0.0-next.170 → 2.0.0-next.171

package/dist/ar/poi-projection/poi-projection.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @module POI Projection
+ *
+ * Media-projection helpers for POI overlays.
+ *
+ * Maps points from media pixel space (video/image natural resolution) to
+ * rendered screen space, accounting for `cover`/`contain` letterboxing.
+ * This is the same math `obc-poi-controller` applies to its
+ * detections-driven targets, exported as pure functions so applications
+ * that manage their own POI elements can project coordinates without
+ * re-implementing the transform.
+ *
+ * ### Usage Guidelines
+ * - Build a {@link MediaProjection} once per resize/metadata change via
+ *   {@link computeMediaProjection}; reuse it for every point in a frame.
+ * - `renderWidth`/`renderHeight` come from the media element's
+ *   `getBoundingClientRect()`; `mediaWidth`/`mediaHeight` from
+ *   `videoWidth`/`videoHeight` (video) or `naturalWidth`/`naturalHeight`
+ *   (image).
+ * - {@link projectPointToLayer} additionally converts a projected
+ *   point into `obc-poi-data` layer coordinates (`x` center px,
+ *   `y` line length from the layer's bottom anchor), given the layer's
+ *   bottom offset inside the projection container.
+ *
+ * ### Fit modes
+ * - `cover`: media fills the container; overflow is cropped.
+ * - `contain`: media letterboxes inside the container.
+ *
+ * The Storybook demo draws the rendered container (outer box), the scaled
+ * media content region (shaded), and a marker at the projected point.
+ */
+/** Fit behavior matching `obc-poi-controller`'s `PoiFitMode` values. */
+export declare enum MediaFit {
+    Cover = "cover",
+    Contain = "contain"
+}
+/** Natural and rendered media dimensions plus the fit mode. */
+export interface MediaProjectionInput {
+    /** Media natural width in px (`videoWidth`/`naturalWidth`). */
+    mediaWidth: number;
+    /** Media natural height in px (`videoHeight`/`naturalHeight`). */
+    mediaHeight: number;
+    /** Rendered element width in px. */
+    renderWidth: number;
+    /** Rendered element height in px. */
+    renderHeight: number;
+    fit: MediaFit;
+}
+/** Resolved projection: uniform scale plus letterbox offsets. */
+export interface MediaProjection {
+    scale: number;
+    /** Horizontal letterbox offset in rendered px (negative when cropped). */
+    offsetX: number;
+    /** Vertical letterbox offset in rendered px (negative when cropped). */
+    offsetY: number;
+    /** Scaled media content width in rendered px. */
+    contentWidth: number;
+    /** Scaled media content height in rendered px. */
+    contentHeight: number;
+}
+/**
+ * Compute the projection for the given dimensions, or `null` when any
+ * dimension is non-finite or zero (media not measured yet).
+ */
+export declare function computeMediaProjection(input: MediaProjectionInput): MediaProjection | null;
+/** Project a point from media pixel space into rendered space. */
+export declare function projectPoint(projection: MediaProjection, x: number, y: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Project a media-space anchor point into `obc-poi-data` layer
+ * coordinates.
+ *
+ * `layerBottom` is the POI layer's bottom edge measured in the same
+ * rendered coordinate space as the projection container (e.g.
+ * `layerRect.bottom - containerRect.top`). The returned `y` is the
+ * connector line length extending downward from the layer to the
+ * target point, clamped to `0` (matches how `obc-poi-controller`
+ * positions its detection targets).
+ */
+export declare function projectPointToLayer(projection: MediaProjection, x: number, y: number, layerBottom: number): {
+    x: number;
+    y: number;
+};
+/** Scale a media-space box dimension into rendered px, or `null`. */
+export declare function projectBoxSize(projection: MediaProjection, size: number | null | undefined): number | null;
+//# sourceMappingURL=poi-projection.d.ts.map

package/dist/ar/poi-projection/poi-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poi-projection.d.ts","sourceRoot":"","sources":["../../../src/ar/poi-projection/poi-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,wEAAwE;AACxE,oBAAY,QAAQ;IAClB,KAAK,UAAU;IACf,OAAO,YAAY;CACpB;AAED,+DAA+D;AAC/D,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,oBAAoB,GAC1B,eAAe,GAAG,IAAI,CA6BxB;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAC1B,UAAU,EAAE,eAAe,EAC3B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAKxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,eAAe,EAC3B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,WAAW,EAAE,MAAM,GAClB;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAMxB;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAC5B,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC9B,MAAM,GAAG,IAAI,CAKf"}

package/dist/ar/poi-projection/poi-projection.js

@@ -0,0 +1,90 @@
+//#region src/ar/poi-projection/poi-projection.ts
+/**
+* @module POI Projection
+*
+* Media-projection helpers for POI overlays.
+*
+* Maps points from media pixel space (video/image natural resolution) to
+* rendered screen space, accounting for `cover`/`contain` letterboxing.
+* This is the same math `obc-poi-controller` applies to its
+* detections-driven targets, exported as pure functions so applications
+* that manage their own POI elements can project coordinates without
+* re-implementing the transform.
+*
+* ### Usage Guidelines
+* - Build a {@link MediaProjection} once per resize/metadata change via
+*   {@link computeMediaProjection}; reuse it for every point in a frame.
+* - `renderWidth`/`renderHeight` come from the media element's
+*   `getBoundingClientRect()`; `mediaWidth`/`mediaHeight` from
+*   `videoWidth`/`videoHeight` (video) or `naturalWidth`/`naturalHeight`
+*   (image).
+* - {@link projectPointToLayer} additionally converts a projected
+*   point into `obc-poi-data` layer coordinates (`x` center px,
+*   `y` line length from the layer's bottom anchor), given the layer's
+*   bottom offset inside the projection container.
+*
+* ### Fit modes
+* - `cover`: media fills the container; overflow is cropped.
+* - `contain`: media letterboxes inside the container.
+*
+* The Storybook demo draws the rendered container (outer box), the scaled
+* media content region (shaded), and a marker at the projected point.
+*/
+/** Fit behavior matching `obc-poi-controller`'s `PoiFitMode` values. */
+var MediaFit = /* @__PURE__ */ function(MediaFit) {
+	MediaFit["Cover"] = "cover";
+	MediaFit["Contain"] = "contain";
+	return MediaFit;
+}({});
+/**
+* Compute the projection for the given dimensions, or `null` when any
+* dimension is non-finite or zero (media not measured yet).
+*/
+function computeMediaProjection(input) {
+	const { mediaWidth, mediaHeight, renderWidth, renderHeight, fit } = input;
+	if (!Number.isFinite(mediaWidth) || !Number.isFinite(mediaHeight) || !Number.isFinite(renderWidth) || !Number.isFinite(renderHeight) || mediaWidth === 0 || mediaHeight === 0 || renderWidth === 0 || renderHeight === 0) return null;
+	const scale = fit === "cover" ? Math.max(renderWidth / mediaWidth, renderHeight / mediaHeight) : Math.min(renderWidth / mediaWidth, renderHeight / mediaHeight);
+	const contentWidth = mediaWidth * scale;
+	const contentHeight = mediaHeight * scale;
+	return {
+		scale,
+		offsetX: (renderWidth - contentWidth) / 2,
+		offsetY: (renderHeight - contentHeight) / 2,
+		contentWidth,
+		contentHeight
+	};
+}
+/** Project a point from media pixel space into rendered space. */
+function projectPoint(projection, x, y) {
+	return {
+		x: projection.offsetX + x * projection.scale,
+		y: projection.offsetY + y * projection.scale
+	};
+}
+/**
+* Project a media-space anchor point into `obc-poi-data` layer
+* coordinates.
+*
+* `layerBottom` is the POI layer's bottom edge measured in the same
+* rendered coordinate space as the projection container (e.g.
+* `layerRect.bottom - containerRect.top`). The returned `y` is the
+* connector line length extending downward from the layer to the
+* target point, clamped to `0` (matches how `obc-poi-controller`
+* positions its detection targets).
+*/
+function projectPointToLayer(projection, x, y, layerBottom) {
+	const projected = projectPoint(projection, x, y);
+	return {
+		x: projected.x,
+		y: Math.max(0, projected.y - layerBottom)
+	};
+}
+/** Scale a media-space box dimension into rendered px, or `null`. */
+function projectBoxSize(projection, size) {
+	if (typeof size !== "number" || !Number.isFinite(size)) return null;
+	return size * projection.scale;
+}
+//#endregion
+export { MediaFit, computeMediaProjection, projectBoxSize, projectPoint, projectPointToLayer };
+
+//# sourceMappingURL=poi-projection.js.map

package/dist/ar/poi-projection/poi-projection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poi-projection.js","names":[],"sources":["../../../src/ar/poi-projection/poi-projection.ts"],"sourcesContent":["/**\n * @module POI Projection\n *\n * Media-projection helpers for POI overlays.\n *\n * Maps points from media pixel space (video/image natural resolution) to\n * rendered screen space, accounting for `cover`/`contain` letterboxing.\n * This is the same math `obc-poi-controller` applies to its\n * detections-driven targets, exported as pure functions so applications\n * that manage their own POI elements can project coordinates without\n * re-implementing the transform.\n *\n * ### Usage Guidelines\n * - Build a {@link MediaProjection} once per resize/metadata change via\n *   {@link computeMediaProjection}; reuse it for every point in a frame.\n * - `renderWidth`/`renderHeight` come from the media element's\n *   `getBoundingClientRect()`; `mediaWidth`/`mediaHeight` from\n *   `videoWidth`/`videoHeight` (video) or `naturalWidth`/`naturalHeight`\n *   (image).\n * - {@link projectPointToLayer} additionally converts a projected\n *   point into `obc-poi-data` layer coordinates (`x` center px,\n *   `y` line length from the layer's bottom anchor), given the layer's\n *   bottom offset inside the projection container.\n *\n * ### Fit modes\n * - `cover`: media fills the container; overflow is cropped.\n * - `contain`: media letterboxes inside the container.\n *\n * The Storybook demo draws the rendered container (outer box), the scaled\n * media content region (shaded), and a marker at the projected point.\n */\n\n/** Fit behavior matching `obc-poi-controller`'s `PoiFitMode` values. */\nexport enum MediaFit {\n  Cover = 'cover',\n  Contain = 'contain',\n}\n\n/** Natural and rendered media dimensions plus the fit mode. */\nexport interface MediaProjectionInput {\n  /** Media natural width in px (`videoWidth`/`naturalWidth`). */\n  mediaWidth: number;\n  /** Media natural height in px (`videoHeight`/`naturalHeight`). */\n  mediaHeight: number;\n  /** Rendered element width in px. */\n  renderWidth: number;\n  /** Rendered element height in px. */\n  renderHeight: number;\n  fit: MediaFit;\n}\n\n/** Resolved projection: uniform scale plus letterbox offsets. */\nexport interface MediaProjection {\n  scale: number;\n  /** Horizontal letterbox offset in rendered px (negative when cropped). */\n  offsetX: number;\n  /** Vertical letterbox offset in rendered px (negative when cropped). */\n  offsetY: number;\n  /** Scaled media content width in rendered px. */\n  contentWidth: number;\n  /** Scaled media content height in rendered px. */\n  contentHeight: number;\n}\n\n/**\n * Compute the projection for the given dimensions, or `null` when any\n * dimension is non-finite or zero (media not measured yet).\n */\nexport function computeMediaProjection(\n  input: MediaProjectionInput\n): MediaProjection | null {\n  const {mediaWidth, mediaHeight, renderWidth, renderHeight, fit} = input;\n  if (\n    !Number.isFinite(mediaWidth) ||\n    !Number.isFinite(mediaHeight) ||\n    !Number.isFinite(renderWidth) ||\n    !Number.isFinite(renderHeight) ||\n    mediaWidth === 0 ||\n    mediaHeight === 0 ||\n    renderWidth === 0 ||\n    renderHeight === 0\n  ) {\n    return null;\n  }\n\n  const scale =\n    fit === MediaFit.Cover\n      ? Math.max(renderWidth / mediaWidth, renderHeight / mediaHeight)\n      : Math.min(renderWidth / mediaWidth, renderHeight / mediaHeight);\n\n  const contentWidth = mediaWidth * scale;\n  const contentHeight = mediaHeight * scale;\n  return {\n    scale,\n    offsetX: (renderWidth - contentWidth) / 2,\n    offsetY: (renderHeight - contentHeight) / 2,\n    contentWidth,\n    contentHeight,\n  };\n}\n\n/** Project a point from media pixel space into rendered space. */\nexport function projectPoint(\n  projection: MediaProjection,\n  x: number,\n  y: number\n): {x: number; y: number} {\n  return {\n    x: projection.offsetX + x * projection.scale,\n    y: projection.offsetY + y * projection.scale,\n  };\n}\n\n/**\n * Project a media-space anchor point into `obc-poi-data` layer\n * coordinates.\n *\n * `layerBottom` is the POI layer's bottom edge measured in the same\n * rendered coordinate space as the projection container (e.g.\n * `layerRect.bottom - containerRect.top`). The returned `y` is the\n * connector line length extending downward from the layer to the\n * target point, clamped to `0` (matches how `obc-poi-controller`\n * positions its detection targets).\n */\nexport function projectPointToLayer(\n  projection: MediaProjection,\n  x: number,\n  y: number,\n  layerBottom: number\n): {x: number; y: number} {\n  const projected = projectPoint(projection, x, y);\n  return {\n    x: projected.x,\n    y: Math.max(0, projected.y - layerBottom),\n  };\n}\n\n/** Scale a media-space box dimension into rendered px, or `null`. */\nexport function projectBoxSize(\n  projection: MediaProjection,\n  size: number | null | undefined\n): number | null {\n  if (typeof size !== 'number' || !Number.isFinite(size)) {\n    return null;\n  }\n  return size * projection.scale;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAY,WAAL,yBAAA,UAAA;CACL,SAAA,WAAA;CACA,SAAA,aAAA;;AACF,EAAA,CAAA,CAAA;;;;;AAgCA,SAAgB,uBACd,OACwB;CACxB,MAAM,EAAC,YAAY,aAAa,aAAa,cAAc,QAAO;CAClE,IACE,CAAC,OAAO,SAAS,UAAU,KAC3B,CAAC,OAAO,SAAS,WAAW,KAC5B,CAAC,OAAO,SAAS,WAAW,KAC5B,CAAC,OAAO,SAAS,YAAY,KAC7B,eAAe,KACf,gBAAgB,KAChB,gBAAgB,KAChB,iBAAiB,GAEjB,OAAO;CAGT,MAAM,QACJ,QAAA,UACI,KAAK,IAAI,cAAc,YAAY,eAAe,WAAW,IAC7D,KAAK,IAAI,cAAc,YAAY,eAAe,WAAW;CAEnE,MAAM,eAAe,aAAa;CAClC,MAAM,gBAAgB,cAAc;CACpC,OAAO;EACL;EACA,UAAU,cAAc,gBAAgB;EACxC,UAAU,eAAe,iBAAiB;EAC1C;EACA;CACF;AACF;;AAGA,SAAgB,aACd,YACA,GACA,GACwB;CACxB,OAAO;EACL,GAAG,WAAW,UAAU,IAAI,WAAW;EACvC,GAAG,WAAW,UAAU,IAAI,WAAW;CACzC;AACF;;;;;;;;;;;;AAaA,SAAgB,oBACd,YACA,GACA,GACA,aACwB;CACxB,MAAM,YAAY,aAAa,YAAY,GAAG,CAAC;CAC/C,OAAO;EACL,GAAG,UAAU;EACb,GAAG,KAAK,IAAI,GAAG,UAAU,IAAI,WAAW;CAC1C;AACF;;AAGA,SAAgB,eACd,YACA,MACe;CACf,IAAI,OAAO,SAAS,YAAY,CAAC,OAAO,SAAS,IAAI,GACnD,OAAO;CAET,OAAO,OAAO,WAAW;AAC3B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oicl/openbridge-webcomponents",
-  "version": "2.0.0-next.170",
+  "version": "2.0.0-next.171",
   "type": "module",
   "repository": {
     "type": "git",
@@ -114,7 +114,7 @@
     "@vitest/browser-playwright": "^4.1.11",
     "conventional-changelog-conventionalcommits": "^9.3.1",
     "dotenv": "^18.0.0",
-    "eslint": "^10.10.0",
+    "eslint": "^10.11.0",
     "eslint-plugin-storybook": "^10.6.0",
     "figma-api": "^2.2.1-beta",
     "glob": "^13.0.6",