* 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.
122 lines
3.2 KiB
TypeScript
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;
|
|
}
|