openmaic-custom/lib/utils/geometry.ts
wyuc 7cb129183d
chore(packages): publish the @openmaic/* SDK family to npm (#778) (#780)
* chore(packages): publish the @openmaic/* SDK family to npm (#778)

Prepares the @openmaic/{dsl,renderer,importer} family for its first npm
publish, and moves the SDK packages onto the @openmaic scope.

Why the scope move: the @maic org name is unavailable on npm (an unscoped
`maic` package already holds the name), so @maic/* is not claimable. @openmaic
matches the project name, the scope is free, and the repo already ships an
@openmaic/docs package — so the SDK family now lines up with that convention.

- rename @maic/{dsl,renderer,importer} -> @openmaic/* across packages, the
  workspace glob, the package dir, and all import sites; lockfile regenerated
- renderer: add publishConfig (public, registry.npmjs.org) — was missing, so
  a scoped publish would default to the wrong registry / restricted access
- importer: add a files allowlist (dist, README, LICENSE) and drop the
  fragile .npmignore blacklist that shipped src; add an exports map so ESM
  consumers resolve dist/index.js instead of falling back to the .cjs main
- all three: add a prepublishOnly build (+ test/typecheck) guard so a publish
  can never ship a stale or empty dist
- add a tag-triggered publish workflow with npm provenance, pinned by name to
  the three @openmaic packages so the vendored forks (mathml2omml, pptxgenjs)
  are never published

Refs #778, #720 (Phase 1).

* fix(packages): address cross-review on the @openmaic publish prep

Cross-review (Claude /code-review + codex) on this PR surfaced:

- renderer's advertised CJS entry was broken: it keeps @openmaic/dsl external
  and imports a runtime enum from it, but dsl is ESM-only (no `require`
  condition), so `require('@openmaic/renderer')` would throw
  ERR_PACKAGE_PATH_NOT_EXPORTED. Make renderer ESM-only: drop the `.cjs`
  rollup output, `main` now points at the ESM build, and the `require`
  conditions are removed from `exports`. (importer is unaffected — it bundles
  dsl, so its CJS build still works.)
- prepublishOnly re-ran the test suite during `pnpm -r publish`, so a flaky
  test after dsl had already published gave a non-atomic partial release.
  Reduce prepublishOnly to a build-only guard (never ship stale/empty dist)
  and move the real test/typecheck gate into the workflow, before any publish.
- document that an @openmaic/* tag publishes the whole family via `pnpm -r`
  (pnpm skips already-published versions); the tag is a release marker, not a
  per-package gate.

Verified: dsl + renderer + importer build; renderer emits ESM only (0 .cjs),
all exports entries resolve; `npm pack` ships dist + README + LICENSE with no
src leak; frozen-lockfile passes.

Refs #778.

* style: reflow @openmaic/dsl type imports past print-width after rename

The @maic -> @openmaic rename lengthened two single-line type imports past
prettier's 100-col width; prettier --check flagged them. Pure formatting.

Refs #778.

* docs(importer): mark @openmaic/importer browser-only (cr-loop accepted limitation)

codex cross-review flagged that the published @openmaic/importer throws
`XMLHttpRequest is not a constructor` when loaded in a pure Node process —
its rollup build is browser-targeted (`nodeResolve({browser:true})` + a
browser pdf.js build). The app only consumes it client-side ('use client'),
so this is by design. Document it as an accepted limitation: prominent
browser-only note in the README and a `browser` field in the manifest.

Refs #778.
2026-06-24 15:12:23 +08:00

122 lines
3.2 KiB
TypeScript

import type { PPTElement } from '@openmaic/dsl';
import type { PercentageGeometry } from '@/lib/types/action';
/**
* Calculate percentage coordinates (0-100) for an element
*
* @param element - PPT element
* @param viewportSize - Viewport width base, default 1000px
* @returns Percentage geometry info, or null if the element has no position info
*/
export function getElementPercentageGeometry(
element: PPTElement,
viewportSize: number = 1000,
): PercentageGeometry | null {
// Only positioned elements have left/top/width/height
if (
!('left' in element) ||
!('top' in element) ||
!('width' in element) ||
!('height' in element)
) {
return null;
}
const { left, top, width, height } = element;
// Calculate percentage coordinates (relative to viewportSize)
const x = (left / viewportSize) * 100;
const y = (top / (viewportSize * 0.5625)) * 100; // 16:9 ratio
const w = (width / viewportSize) * 100;
const h = (height / (viewportSize * 0.5625)) * 100;
// Calculate center point
const centerX = x + w / 2;
const centerY = y + h / 2;
return {
x,
y,
w,
h,
centerX,
centerY,
};
}
/**
* Find percentage geometry info by scene and element ID
*
* @param scene - Scene object
* @param elementId - Element ID
* @param viewportSize - Viewport width base, default 1000px
* @returns Percentage geometry info, or null if element is not found or has no position info
*/
export function findElementGeometry(
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- scene can be old or new format with different shapes
scene: Record<string, any>,
elementId: string,
viewportSize: number = 1000,
): PercentageGeometry | null {
// Support two scene structures:
// 1. scene.elements (old format)
// 2. scene.content.canvas.elements (new format)
let elements: PPTElement[] | undefined;
if (scene.type === 'slide') {
if (scene.elements) {
// Old format
elements = scene.elements;
} else if (scene.content?.canvas?.elements) {
// New format
elements = scene.content.canvas.elements;
}
}
if (!elements) {
return null;
}
const element = elements.find((el: PPTElement) => el.id === elementId);
if (!element) {
return null;
}
return getElementPercentageGeometry(element, viewportSize);
}
/**
* Calculate which corner has the shortest distance to the element center
*
* @param geometry - Percentage geometry info
* @returns Nearest corner coordinates { x: 0-100, y: 0-100 }
*/
export function findNearestCorner(geometry: PercentageGeometry): {
x: number;
y: number;
} {
const { centerX, centerY } = geometry;
// Coordinates of the four corners
const corners = [
{ x: 0, y: 0 }, // Top-left
{ x: 100, y: 0 }, // Top-right
{ x: 0, y: 100 }, // Bottom-left
{ x: 100, y: 100 }, // Bottom-right
];
// Calculate distances and find the nearest corner
let minDistance = Infinity;
let nearestCorner = corners[0];
for (const corner of corners) {
const distance = Math.sqrt(Math.pow(corner.x - centerX, 2) + Math.pow(corner.y - centerY, 2));
if (distance < minDistance) {
minDistance = distance;
nearestCorner = corner;
}
}
return nearestCorner;
}