pptx-angular-viewer 4.1.6 → 4.2.0

package/fesm2022/pptx-angular-viewer-index-7b9uo9P2.mjs

@@ -1,655 +0,0 @@
-import { CanvasTexture, SRGBColorSpace, LinearFilter, RepeatWrapping, Shape, ExtrudeGeometry, MeshStandardMaterial, Color, Mesh, EdgesGeometry, LineBasicMaterial, LineSegments, PlaneGeometry, MeshBasicMaterial, DoubleSide, Euler, Vector3, BufferGeometry, Line, Group, WebGLRenderer, Scene, PerspectiveCamera, AmbientLight, DirectionalLight } from 'three';
-import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
-
-/**
- * Three.js SmartArt renderer - front-face text textures.
- *
- * Renders a node label onto an offscreen 2D canvas and wraps it as a
- * `THREE.CanvasTexture`, sized to sit on the extruded block's front face. Text
- * is word-wrapped and auto-shrunk to fit the node footprint. Returns `null` in
- * non-DOM environments (SSR / unit tests).
- */
-/** Supersampling factor for crisp text at oblique camera angles. */
-const SUPERSAMPLE = 4;
-/** Fraction of the footprint the text plane occupies (inset padding). */
-const FILL = 0.86;
-/** Greedily word-wrap `text` to lines that fit `maxWidth` at the given font. */
-function wrapLines(ctx, text, maxWidth) {
-    const words = text.split(/\s+/u).filter(Boolean);
-    if (words.length === 0) {
-        return [];
-    }
-    const lines = [];
-    let line = words[0];
-    for (let i = 1; i < words.length; i++) {
-        const candidate = `${line} ${words[i]}`;
-        if (ctx.measureText(candidate).width <= maxWidth) {
-            line = candidate;
-        }
-        else {
-            lines.push(line);
-            line = words[i];
-        }
-    }
-    lines.push(line);
-    return lines;
-}
-/** Resolve the canvas `font` string weight/style + effective colour for an optional emphasis override. */
-function resolveEmphasisFont(color, emphasis) {
-    const weight = emphasis?.bold === undefined ? '600' : emphasis.bold ? '700' : '400';
-    const italic = emphasis?.italic ? 'italic ' : '';
-    const scale = typeof emphasis?.fontScale === 'number' &&
-        Number.isFinite(emphasis.fontScale) &&
-        emphasis.fontScale > 0
-        ? emphasis.fontScale
-        : 1;
-    return { weight, italic, color: emphasis?.color ?? color, scale };
-}
-/**
- * Build a label texture for a node's front face.
- *
- * @param text      Label text.
- * @param color     CSS colour for the text.
- * @param fontSize  Requested font size in layout pixels.
- * @param footW     Node footprint width (layout pixels).
- * @param footH     Node footprint height (layout pixels).
- * @param emphasis  Active font-style emphasis override (bold/italic/underline/size/colour), if any.
- * @returns The texture + plane size, or `null` when no DOM / empty text.
- */
-function makeTextTexture(text, color, fontSize, footW, footH, emphasis) {
-    if (typeof document === 'undefined' || !text.trim() || footW <= 0 || footH <= 0) {
-        return null;
-    }
-    const { weight, italic, color: effectiveColor, scale } = resolveEmphasisFont(color, emphasis);
-    const worldWidth = footW * FILL;
-    const worldHeight = footH * FILL;
-    const canvas = document.createElement('canvas');
-    canvas.width = Math.max(8, Math.round(worldWidth * SUPERSAMPLE));
-    canvas.height = Math.max(8, Math.round(worldHeight * SUPERSAMPLE));
-    const ctx = canvas.getContext('2d');
-    if (!ctx) {
-        return null;
-    }
-    const family = 'system-ui, -apple-system, Segoe UI, Roboto, sans-serif';
-    const maxTextWidth = canvas.width * 0.94;
-    const fontString = (px) => `${italic}${weight} ${px}px ${family}`;
-    // Shrink the font until the wrapped block fits the canvas height.
-    let px = Math.max(6, fontSize) * scale * SUPERSAMPLE;
-    let lines = [];
-    for (let attempt = 0; attempt < 12; attempt++) {
-        ctx.font = fontString(px);
-        lines = wrapLines(ctx, text, maxTextWidth);
-        const lineHeight = px * 1.2;
-        if (lines.length * lineHeight <= canvas.height * 0.96 || px <= 6 * SUPERSAMPLE) {
-            break;
-        }
-        px *= 0.88;
-    }
-    ctx.clearRect(0, 0, canvas.width, canvas.height);
-    ctx.fillStyle = effectiveColor;
-    ctx.textAlign = 'center';
-    ctx.textBaseline = 'middle';
-    ctx.font = fontString(px);
-    const lineHeight = px * 1.2;
-    const blockHeight = lines.length * lineHeight;
-    const startY = canvas.height / 2 - blockHeight / 2 + lineHeight / 2;
-    for (let i = 0; i < lines.length; i++) {
-        const y = startY + i * lineHeight;
-        ctx.fillText(lines[i], canvas.width / 2, y);
-        if (emphasis?.underline) {
-            const w = ctx.measureText(lines[i]).width;
-            ctx.strokeStyle = effectiveColor;
-            ctx.lineWidth = Math.max(1, px * 0.06);
-            ctx.beginPath();
-            ctx.moveTo(canvas.width / 2 - w / 2, y + px * 0.32);
-            ctx.lineTo(canvas.width / 2 + w / 2, y + px * 0.32);
-            ctx.stroke();
-        }
-    }
-    const texture = new CanvasTexture(canvas);
-    texture.colorSpace = SRGBColorSpace;
-    texture.minFilter = LinearFilter;
-    texture.magFilter = LinearFilter;
-    // Disable GPU-side flip: WebGL2 does not allow UNPACK_FLIP_Y_WEBGL for
-    // texImage3D targets (depth buffers, LUTs, shadow maps). Leaving flipY=true
-    // (the Three.js default) pollutes the global pixel-store state and causes
-    // "INVALID_OPERATION: texImage3D: FLIP_Y or PREMULTIPLY_ALPHA isn't allowed"
-    // errors. Compensate in UV space instead.
-    texture.flipY = false;
-    texture.premultiplyAlpha = false;
-    texture.wrapT = RepeatWrapping;
-    texture.repeat.set(1, -1);
-    texture.offset.set(0, 1);
-    texture.needsUpdate = true;
-    return { texture, worldWidth, worldHeight };
-}
-
-/**
- * Three.js SmartArt renderer - mesh-group construction.
- *
- * Turns a pure {@link SmartArt3DModel} into a `THREE.Group` of extruded blocks
- * (with bevels, edge outlines, and front-face text planes) plus connector
- * lines. All allocated GPU resources are tracked so the caller can dispose them
- * deterministically.
- */
-/** Build the extruded geometry for one node. */
-function extrudeGeometry(m) {
-    const shape = new Shape();
-    m.outline.forEach((p, i) => {
-        if (i === 0) {
-            shape.moveTo(p.x, p.y);
-        }
-        else {
-            shape.lineTo(p.x, p.y);
-        }
-    });
-    shape.closePath();
-    const bevelEnabled = m.bevel > 0;
-    return new ExtrudeGeometry(shape, {
-        depth: m.depth,
-        bevelEnabled,
-        bevelThickness: m.bevel,
-        bevelSize: m.bevel,
-        bevelSegments: 2,
-        curveSegments: m.rounded ? 24 : 1,
-        steps: 1,
-    });
-}
-/** Add the extruded block + edge outline for one node to the group. */
-function addBlock(group, disposables, m) {
-    const geo = extrudeGeometry(m);
-    const material = new MeshStandardMaterial({
-        color: new Color(m.fill),
-        metalness: 0.12,
-        roughness: 0.52,
-        transparent: m.opacity < 1,
-        opacity: m.opacity,
-    });
-    const mesh = new Mesh(geo, material);
-    mesh.position.set(m.position.x, m.position.y, m.position.z);
-    mesh.rotation.set(m.rotation.x, m.rotation.y, m.rotation.z);
-    group.add(mesh);
-    disposables.push(geo, material);
-    if (m.strokeWidth > 0) {
-        const edges = new EdgesGeometry(geo, 30);
-        const lineMaterial = new LineBasicMaterial({ color: new Color(m.stroke) });
-        const line = new LineSegments(edges, lineMaterial);
-        line.position.copy(mesh.position);
-        line.rotation.copy(mesh.rotation);
-        group.add(line);
-        disposables.push(edges, lineMaterial);
-    }
-    return geo;
-}
-/** Build a front-face text plane for one node, or `null` when it has no label / no DOM. */
-function buildLabelPlane(m, textStyle) {
-    if (!m.text) {
-        return null;
-    }
-    const tex = makeTextTexture(m.text, m.textColor, m.fontSize, m.halfWidth * 2, m.halfHeight * 2, textStyle);
-    if (!tex) {
-        return null;
-    }
-    const planeGeo = new PlaneGeometry(tex.worldWidth, tex.worldHeight);
-    // Double-sided: spatial layouts (the cycle/radial carousel ring) rotate
-    // roughly half the nodes so their front face points away from the
-    // camera's default position. A single-sided (default `FrontSide`)
-    // material culls that view entirely, so those nodes render with no
-    // caption at all; double-siding keeps the label visible (mirrored, on
-    // the far side) instead of vanishing. `scene.ts`'s render loop billboards
-    // every plane toward the camera each frame, which overrides this initial
-    // rotation once mounted (see `BuiltMeshGroup.forEachLabelPlane`); this
-    // still matters for a caller that never renders a frame (tests) and as
-    // the visible starting orientation before the first billboard update.
-    // `depthTest: false` also matters once billboarded: the plane's offset
-    // (below) clears the block along the block's OWN original facing
-    // direction, which is not necessarily toward the camera once the plane
-    // itself has been rotated to face the camera instead, so a depth-tested
-    // plane could end up partially behind its own (or a neighbouring) node's
-    // extrusion from the camera's actual angle. Skipping the depth test
-    // keeps every caption drawn on top, which is the legible outcome we
-    // want for a small, sparse set of node labels.
-    const planeMaterial = new MeshBasicMaterial({
-        map: tex.texture,
-        transparent: true,
-        depthWrite: false,
-        depthTest: false,
-        side: DoubleSide,
-    });
-    const plane = new Mesh(planeGeo, planeMaterial);
-    plane.renderOrder = 1;
-    // Float just past the front (+z) face, clearing any bevel, following the
-    // mesh's rotation so the label sits flat on the (possibly rotated) face.
-    const euler = new Euler(m.rotation.x, m.rotation.y, m.rotation.z);
-    const offset = new Vector3(0, 0, m.depth + m.bevel + 0.4).applyEuler(euler);
-    plane.position.set(m.position.x + offset.x, m.position.y + offset.y, m.position.z + offset.z);
-    plane.rotation.copy(euler);
-    return { plane, disposables: [planeGeo, planeMaterial, tex.texture] };
-}
-/** Add a connector poly-line on the base plane. */
-function addConnectors(group, disposables, model) {
-    for (const c of model.connectors) {
-        if (c.points.length < 2) {
-            continue;
-        }
-        const geo = new BufferGeometry().setFromPoints(c.points.map((p) => new Vector3(p.x, p.y, p.z)));
-        const material = new LineBasicMaterial({
-            color: new Color(c.color),
-            transparent: true,
-            opacity: 0.7,
-        });
-        group.add(new Line(geo, material));
-        disposables.push(geo, material);
-    }
-}
-/** Remove and dispose one label entry's current plane, if any. */
-function clearLabel(group, entry) {
-    if (entry.plane) {
-        group.remove(entry.plane);
-    }
-    for (const d of entry.disposables) {
-        d.dispose();
-    }
-    entry.plane = null;
-    entry.disposables = [];
-}
-/**
- * Build a `THREE.Group` for a SmartArt 3D model. The group is centred on the
- * origin (the model positions already are); callers add it to the scene.
- * `textStyle` is a font-style emphasis override applied to every node's
- * label (see {@link BuiltMeshGroup.setTextStyle}); emphasis is authored per
- * shape/animation-target, not per SmartArt node, so it applies uniformly.
- *
- * A label plane's *position* floats just off its node's own front (radially
- * outward, for a spatial/carousel arrangement) face, following the node's
- * rotation - but its *rotation* is left at that same face-following value
- * only as an initial default. `mountSmartArt3D`'s render loop re-orients
- * every plane toward the camera each frame via {@link BuiltMeshGroup.forEachLabelPlane}
- * (a Y-axis-only billboard, so captions stay upright and legible). Without
- * that, a node whose front face happens to point away from or across the
- * camera - unavoidable for roughly half of any ring/carousel arrangement -
- * would have an edge-on or backward-facing caption: `DoubleSide` (see
- * `buildLabelPlane`) fixes the "backward" case, but nothing short of facing
- * the plane at the camera fixes "edge-on".
- */
-function buildMeshGroup(model, textStyle) {
-    const group = new Group();
-    const blockDisposables = [];
-    const labelEntries = model.meshes.map((m) => {
-        addBlock(group, blockDisposables, m);
-        const built = buildLabelPlane(m, textStyle);
-        if (built) {
-            group.add(built.plane);
-        }
-        return { node: m, plane: built?.plane ?? null, disposables: built?.disposables ?? [] };
-    });
-    addConnectors(group, blockDisposables, model);
-    return {
-        group,
-        setTextStyle(style) {
-            for (const entry of labelEntries) {
-                clearLabel(group, entry);
-                const built = buildLabelPlane(entry.node, style);
-                if (built) {
-                    group.add(built.plane);
-                    entry.plane = built.plane;
-                    entry.disposables = built.disposables;
-                }
-            }
-        },
-        forEachLabelPlane(fn) {
-            for (const entry of labelEntries) {
-                if (entry.plane) {
-                    fn(entry.plane);
-                }
-            }
-        },
-        dispose() {
-            for (const d of blockDisposables) {
-                d.dispose();
-            }
-            for (const entry of labelEntries) {
-                clearLabel(group, entry);
-            }
-        },
-    };
-}
-
-/**
- * Three.js SmartArt renderer - camera framing + label billboarding math.
- *
- * Pure geometry (no `three` rendering calls beyond the `Mesh`/`PerspectiveCamera`
- * types billboarding reads from) split out of `scene.ts` to keep that module
- * focused on mount/render-loop orchestration. Exported for unit tests
- * (`scene-camera.test.ts`); not part of the `pptx-viewer-shared/smartart-3d`
- * public subpath barrel (`index.ts`), which only re-exports `mountSmartArt3D`.
- */
-/** Vertical field of view (degrees) the mounted camera uses. */
-const FOV = 42;
-/**
- * Expand `bounds` by one mesh's true world-space footprint.
- *
- * Every mesh here only ever rotates about Y (see `applySpatialLayout`), so a
- * mesh's local box - footprint half-extents `(halfWidth, halfHeight)` in its
- * own XY plane, and an extrusion that spans local z from `0` to
- * `depth` (plus a small bevel overshoot on both ends) - can be exactly
- * reprojected into world X/Z with the standard rotated-box formula
- * (`|halfExtent * cos| + |otherHalfExtent * sin|` per axis). Using a single
- * scalar radius applied equally to every world axis (the previous approach)
- * conflated the footprint size with the much smaller extrusion depth,
- * wildly overstating a wide/flat node's extent along its through-face axis
- * and pushing the fit-to-frame camera far past where the content actually
- * needed it, so the whole diagram rendered tiny inside its frame.
- */
-function expandForMesh(expand, m) {
-    const hx = m.halfWidth + m.bevel;
-    const hy = m.halfHeight + m.bevel;
-    const hz = m.depth / 2 + m.bevel;
-    const midZ = m.position.z + m.depth / 2;
-    const cosY = Math.cos(m.rotation.y);
-    const sinY = Math.sin(m.rotation.y);
-    const worldHalfX = Math.abs(hx * cosY) + Math.abs(hz * sinY);
-    const worldHalfZ = Math.abs(hx * sinY) + Math.abs(hz * cosY);
-    expand(m.position.x, m.position.y, midZ, worldHalfX, hy, worldHalfZ);
-}
-/** Bounding sphere of all meshes (rotation-aware) + connectors. */
-function contentSphere(model) {
-    let minX = Infinity;
-    let minY = Infinity;
-    let minZ = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    let maxZ = -Infinity;
-    const expand = (x, y, z, rx, ry, rz) => {
-        minX = Math.min(minX, x - rx);
-        minY = Math.min(minY, y - ry);
-        minZ = Math.min(minZ, z - rz);
-        maxX = Math.max(maxX, x + rx);
-        maxY = Math.max(maxY, y + ry);
-        maxZ = Math.max(maxZ, z + rz);
-    };
-    for (const m of model.meshes) {
-        expandForMesh(expand, m);
-    }
-    for (const c of model.connectors) {
-        for (const p of c.points) {
-            expand(p.x, p.y, p.z, 1, 1, 1);
-        }
-    }
-    if (!Number.isFinite(minX)) {
-        const halfW = model.bounds.width / 2 || 1;
-        const halfH = model.bounds.height / 2 || 1;
-        const fallback = Math.max(halfW, halfH);
-        return { cx: 0, cy: 0, cz: 0, radius: fallback, halfW, halfH, halfD: 1 };
-    }
-    return {
-        cx: (minX + maxX) / 2,
-        cy: (minY + maxY) / 2,
-        cz: (minZ + maxZ) / 2,
-        radius: 0.5 * Math.hypot(maxX - minX, maxY - minY, maxZ - minZ) || 1,
-        halfW: (maxX - minX) / 2,
-        halfH: (maxY - minY) / 2,
-        halfD: (maxZ - minZ) / 2,
-    };
-}
-/** Camera distance that frames a bounding sphere of `radius` at the given FOV. */
-function frameDistance(radius, aspect) {
-    const vFov = (FOV * Math.PI) / 180;
-    const hFov = 2 * Math.atan(Math.tan(vFov / 2) * aspect);
-    const minFov = Math.min(vFov, hFov);
-    return (radius / Math.sin(minFov / 2)) * 1.1;
-}
-/** Fraction of the frame the content's projected box may occupy on its tightest axis. */
-const FRAME_FILL = 0.92;
-/**
- * Place the camera in front of the content: a slight x offset + elevation
- * gives the extrusion/spatial depth a readable three-quarter presence while
- * framing the content's own centroid (`cameraElevation` picks the tilt).
- */
-function placeCamera(bounds, family, dist) {
-    const { cx, cy, cz, radius } = bounds;
-    const elevation = cameraElevation(family, radius, dist);
-    return {
-        position: [cx + radius * 0.25, cy + elevation, cz + dist],
-        target: [cx, cy, cz],
-        dist,
-    };
-}
-/**
- * Largest ratio of a content-box corner's projected offset to the frame's
- * half-extent, seen from `placement`: `1` means the box exactly touches the
- * frame edge on its tightest axis, `>1` means it overflows. Corners behind
- * the camera count as infinitely overflowing.
- */
-function projectedFill(bounds, placement, aspect) {
-    const vFov = (FOV * Math.PI) / 180;
-    const tanV = Math.tan(vFov / 2);
-    const tanH = tanV * aspect;
-    const [px, py, pz] = placement.position;
-    const [tx, ty, tz] = placement.target;
-    // Camera basis: forward toward the target, right = forward x worldUp, up = right x forward.
-    let fx = tx - px, fy = ty - py, fz = tz - pz;
-    const fl = Math.hypot(fx, fy, fz) || 1;
-    fx /= fl;
-    fy /= fl;
-    fz /= fl;
-    let rx = -fz, rz = fx;
-    const rl = Math.hypot(rx, rz) || 1;
-    rx /= rl;
-    rz /= rl;
-    const ux = -rz * fy, uy = rz * fx - rx * fz, uz = rx * fy;
-    let worst = 0;
-    for (const sx of [-1, 1]) {
-        for (const sy of [-1, 1]) {
-            for (const sz of [-1, 1]) {
-                const dx = bounds.cx + sx * bounds.halfW - px;
-                const dy = bounds.cy + sy * bounds.halfH - py;
-                const dz = bounds.cz + sz * bounds.halfD - pz;
-                const depth = dx * fx + dy * fy + dz * fz;
-                if (depth <= 1e-6) {
-                    return Infinity;
-                }
-                const x = Math.abs(dx * rx + dz * rz) / (depth * tanH);
-                const y = Math.abs(dx * ux + dy * uy + dz * uz) / (depth * tanV);
-                worst = Math.max(worst, x, y);
-            }
-        }
-    }
-    return worst;
-}
-/**
- * Camera placement whose view fits the content's projected bounding BOX to
- * the frame (`FRAME_FILL` of the tightest axis).
- *
- * `frameDistance` fits the bounding SPHERE to the smaller field of view,
- * which is only tight for roughly cubic content: a wide, flat list diagram
- * (600 x 340 x 40) has a sphere nearly as wide as the diagram but the frame
- * is 1.76x wider than it is tall, so the sphere fit left the diagram at ~45%
- * of the frame width with its captions unreadably small. Starting from the
- * sphere fit, this re-projects the box's eight corners through the actual
- * (elevated, x-offset) camera and rescales the distance until the box just
- * fills the frame; the ratio is close to linear in `dist`, so a handful of
- * fixed-point steps converge.
- */
-function fitCamera(bounds, family, aspect) {
-    let dist = frameDistance(bounds.radius, aspect);
-    let placement = placeCamera(bounds, family, dist);
-    for (let step = 0; step < 8; step++) {
-        const fill = projectedFill(bounds, placement, aspect);
-        if (!Number.isFinite(fill)) {
-            dist *= 2;
-        }
-        else {
-            const ratio = fill / FRAME_FILL;
-            if (Math.abs(ratio - 1) < 0.01) {
-                break;
-            }
-            dist *= ratio;
-        }
-        placement = placeCamera(bounds, family, dist);
-    }
-    return placement;
-}
-/** Elevation angle (degrees, above the content's own horizontal plane) for a near-overhead ring view. */
-const CAROUSEL_ELEVATION_DEG = 34;
-/**
- * World-space Y offset for the camera above the content's own centroid.
- *
- * `cycleSpatial` (see `smartart-3d-spatial.ts`) flattens every node onto
- * `y = 0`, arranging them on a ring in the XZ plane. The default modest
- * elevation (a good three-quarter tilt for extruded-flat and receding-tree
- * content, which both keep real vertical extent) views that flat ring
- * almost edge-on: nodes on the far side of the ring sit almost directly
- * behind the near ones from the camera's angle, so the diagram reads as a
- * couple of overlapping shapes instead of the circle the 2D layout shows.
- * A steep, near-overhead elevation (expressed as a fixed angle, not a
- * fraction of `radius`, so it holds regardless of the radius/distance
- * ratio) opens the ring up into a readable circle, matching the 2D
- * cycle/radial layout's own top-down gestalt.
- */
-function cameraElevation(family, radius, dist) {
-    if (family === 'cycle' || family === 'radial') {
-        return dist * Math.tan((CAROUSEL_ELEVATION_DEG * Math.PI) / 180);
-    }
-    return radius * 0.3;
-}
-/**
- * Y-axis-only billboard: rotate every label plane to face the camera's
- * current azimuth, keeping the plane vertical (so captions never tilt or
- * flip upside down).
- *
- * A label's position floats just off its node's own (possibly rotated,
- * possibly radially-outward-facing) front face, but a plane rotated to
- * match that face is only readable when the camera happens to be roughly
- * in front of it. For a spatial/carousel arrangement (`cycleSpatial`),
- * that is true for at most the ~180 degrees of the ring facing the
- * camera, and only good for reading text within roughly +/-45 degrees of
- * dead-on; nodes further round the ring go edge-on (near-zero projected
- * width; `DoubleSide` on the material does not help, since that only
- * fixes a plane facing directly away, not sideways) or fully backward.
- * Re-orienting the plane itself toward the camera, every frame (so this
- * keeps working through an interactive orbit), makes every node's caption
- * legible regardless of which way its underlying block happens to face.
- */
-function billboardLabels(built, camera) {
-    built.forEachLabelPlane((plane) => {
-        const dx = camera.position.x - plane.position.x;
-        const dz = camera.position.z - plane.position.z;
-        plane.rotation.set(0, Math.atan2(dx, dz), 0);
-    });
-}
-
-/**
- * Three.js SmartArt renderer - vanilla scene runtime.
- *
- * Frames a {@link SmartArt3DModel} in a WebGL scene (lights, perspective
- * camera, optional OrbitControls, render loop) on a caller-provided canvas.
- * Pure vanilla three.js - no framework code - so the React, Vue, and Angular
- * bindings all mount it through a thin canvas wrapper. `three` is imported here
- * only; this module lives behind the `pptx-viewer-shared/smartart-3d` subpath so
- * it is lazily loaded and `three` stays an optional dependency.
- *
- * Camera framing (`contentSphere`/`fitCamera`/`cameraElevation`) and label
- * billboarding (`billboardLabels`) are pure geometry, split out to
- * `scene-camera.ts` to keep this module focused on mount/render-loop
- * orchestration.
- */
-/**
- * Mount a SmartArt 3D model onto a canvas and start rendering.
- *
- * @returns a handle for resizing, toggling interactivity, and disposal.
- */
-function mountSmartArt3D(canvas, model, width, height, options = {}) {
-    const renderer = new WebGLRenderer({ canvas, antialias: true, alpha: !options.background });
-    renderer.setPixelRatio(Math.min(typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1, options.maxPixelRatio ?? 2));
-    renderer.setSize(width, height, false);
-    const scene = new Scene();
-    if (options.background) {
-        scene.background = new Color(options.background);
-    }
-    const bounds = contentSphere(model);
-    const { cx, cy, cz, radius } = bounds;
-    const aspect = width / Math.max(1, height);
-    // Fit the content's projected bounding box (not just its sphere) to the
-    // frame; see `fitCamera` for why the sphere fit alone left wide, flat
-    // diagrams tiny.
-    const placement = fitCamera(bounds, model.family, aspect);
-    const { dist } = placement;
-    const camera = new PerspectiveCamera(FOV, aspect, 0.1, dist * 8 + radius * 4);
-    camera.position.set(...placement.position);
-    camera.lookAt(...placement.target);
-    scene.add(new AmbientLight(0xffffff, 0.62));
-    const key = new DirectionalLight(0xffffff, 0.95);
-    key.position.set(cx + radius, cy + radius * 1.4, cz + dist);
-    scene.add(key);
-    const fill = new DirectionalLight(0xffffff, 0.3);
-    fill.position.set(cx - radius, cy - radius * 0.6, cz + dist * 0.6);
-    scene.add(fill);
-    const built = buildMeshGroup(model, options.textStyle);
-    scene.add(built.group);
-    let controls = null;
-    const enableControls = (on) => {
-        if (on && !controls) {
-            controls = new OrbitControls(camera, canvas);
-            controls.enablePan = false;
-            controls.target.set(cx, cy, cz);
-            controls.minDistance = dist * 0.4;
-            controls.maxDistance = dist * 3;
-            controls.update();
-        }
-        else if (!on && controls) {
-            controls.dispose();
-            controls = null;
-        }
-        if (controls) {
-            controls.autoRotate = Boolean(options.autoRotate);
-            controls.autoRotateSpeed = 1.2;
-        }
-    };
-    enableControls(Boolean(options.interactive));
-    let frame = 0;
-    let disposed = false;
-    const renderLoop = () => {
-        if (disposed) {
-            return;
-        }
-        frame = requestAnimationFrame(renderLoop);
-        billboardLabels(built, camera);
-        controls?.update();
-        renderer.render(scene, camera);
-    };
-    frame = requestAnimationFrame(renderLoop);
-    return {
-        resize(w, h) {
-            camera.aspect = w / Math.max(1, h);
-            camera.updateProjectionMatrix();
-            renderer.setSize(w, h, false);
-        },
-        setInteractive(on) {
-            enableControls(on);
-        },
-        setTextStyle(style) {
-            built.setTextStyle(style);
-        },
-        dispose() {
-            disposed = true;
-            cancelAnimationFrame(frame);
-            controls?.dispose();
-            built.dispose();
-            renderer.dispose();
-        },
-    };
-}
-
-/**
- * `pptx-viewer-shared/smartart-3d` - vanilla three.js SmartArt scene runtime.
- *
- * Lazily imported by each binding's SmartArt 3D wrapper so `three` stays an
- * optional dependency: when it is not installed the dynamic import rejects and
- * the binding falls back to the SVG `SmartArtRenderer`. The pure model builder
- * (`buildSmartArt3DModel`) and its types live in the main barrel
- * (`pptx-viewer-shared`) and should be imported from there directly.
- */
-
-export { mountSmartArt3D };
-//# sourceMappingURL=pptx-angular-viewer-index-7b9uo9P2.mjs.map