@aixa-transformation/pptx-viewer 2.0.2

package/dist/Model3DScene-5ODZLKJM.mjs

@@ -0,0 +1,49 @@
+import { mountModel3D } from './chunk-XAVVR6OX.mjs';
+import './chunk-KVM4DBEU.mjs';
+import './chunk-6DZX6EAA.mjs';
+import { useRef, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function Model3DScene({ modelUrl, interactive, width, height }) {
+  const containerRef = useRef(null);
+  const handleRef = useRef(null);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) {
+      return;
+    }
+    let disposed = false;
+    void mountModel3D(container, modelUrl, { width, height, interactive }).then((handle) => {
+      if (disposed) {
+        handle.dispose();
+      } else {
+        handleRef.current = handle;
+      }
+      return void 0;
+    });
+    return () => {
+      disposed = true;
+      handleRef.current?.dispose();
+      handleRef.current = null;
+    };
+  }, [modelUrl]);
+  useEffect(() => {
+    handleRef.current?.setInteractive(interactive);
+  }, [interactive]);
+  useEffect(() => {
+    handleRef.current?.resize(width, height);
+  }, [width, height]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: containerRef,
+      style: {
+        width,
+        height,
+        willChange: "transform"
+      }
+    }
+  );
+}
+
+export { Model3DScene as default };

package/dist/Model3DScene-VLHFNN5B.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var chunk2TOLRBFU_js = require('./chunk-2TOLRBFU.js');
+require('./chunk-AD2CLKY6.js');
+require('./chunk-QGM4M3NI.js');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function Model3DScene({ modelUrl, interactive, width, height }) {
+  const containerRef = react.useRef(null);
+  const handleRef = react.useRef(null);
+  react.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) {
+      return;
+    }
+    let disposed = false;
+    void chunk2TOLRBFU_js.mountModel3D(container, modelUrl, { width, height, interactive }).then((handle) => {
+      if (disposed) {
+        handle.dispose();
+      } else {
+        handleRef.current = handle;
+      }
+      return void 0;
+    });
+    return () => {
+      disposed = true;
+      handleRef.current?.dispose();
+      handleRef.current = null;
+    };
+  }, [modelUrl]);
+  react.useEffect(() => {
+    handleRef.current?.setInteractive(interactive);
+  }, [interactive]);
+  react.useEffect(() => {
+    handleRef.current?.resize(width, height);
+  }, [width, height]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: containerRef,
+      style: {
+        width,
+        height,
+        willChange: "transform"
+      }
+    }
+  );
+}
+
+module.exports = Model3DScene;

package/dist/OrbitControls-HI6CI76Z.mjs

@@ -0,0 +1,3 @@
+export { OrbitControls } from './chunk-F3LO2NKI.mjs';
+import './chunk-W5V6CEFL.mjs';
+import './chunk-6DZX6EAA.mjs';

package/dist/OrbitControls-XGY7XEC6.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkDAKELFNP_js = require('./chunk-DAKELFNP.js');
+require('./chunk-SQY54X47.js');
+require('./chunk-QGM4M3NI.js');
+
+
+
+Object.defineProperty(exports, "OrbitControls", {
+  enumerable: true,
+  get: function () { return chunkDAKELFNP_js.OrbitControls; }
+});

package/dist/SmartArt3DScene-3FL5JELA.mjs

@@ -0,0 +1,333 @@
+import { OrbitControls } from './chunk-F3LO2NKI.mjs';
+import { WebGLRenderer, Scene, Color, PerspectiveCamera, AmbientLight, DirectionalLight, Group, MeshStandardMaterial, Mesh, EdgesGeometry, LineBasicMaterial, LineSegments, PlaneGeometry, MeshBasicMaterial, Euler, Vector3, BufferGeometry, Line, Shape, ExtrudeGeometry, CanvasTexture, SRGBColorSpace, LinearFilter, RepeatWrapping } from './chunk-W5V6CEFL.mjs';
+import './chunk-6DZX6EAA.mjs';
+import { useRef, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// ../shared/dist/smartart-3d/index.mjs
+var SUPERSAMPLE = 4;
+var FILL = 0.86;
+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;
+}
+function makeTextTexture(text, color, fontSize, footW, footH) {
+  if (typeof document === "undefined" || !text.trim() || footW <= 0 || footH <= 0) {
+    return null;
+  }
+  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;
+  let px = Math.max(6, fontSize) * SUPERSAMPLE;
+  let lines = [];
+  for (let attempt = 0; attempt < 12; attempt++) {
+    ctx.font = `600 ${px}px ${family}`;
+    lines = wrapLines(ctx, text, maxTextWidth);
+    const lineHeight2 = px * 1.2;
+    if (lines.length * lineHeight2 <= canvas.height * 0.96 || px <= 6 * SUPERSAMPLE) {
+      break;
+    }
+    px *= 0.88;
+  }
+  ctx.clearRect(0, 0, canvas.width, canvas.height);
+  ctx.fillStyle = color;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+  ctx.font = `600 ${px}px ${family}`;
+  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++) {
+    ctx.fillText(lines[i], canvas.width / 2, startY + i * lineHeight);
+  }
+  const texture = new CanvasTexture(canvas);
+  texture.colorSpace = SRGBColorSpace;
+  texture.minFilter = LinearFilter;
+  texture.magFilter = LinearFilter;
+  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 };
+}
+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
+  });
+}
+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;
+}
+function addLabel(group, disposables, m) {
+  if (!m.text) {
+    return;
+  }
+  const tex = makeTextTexture(m.text, m.textColor, m.fontSize, m.halfWidth * 2, m.halfHeight * 2);
+  if (!tex) {
+    return;
+  }
+  const planeGeo = new PlaneGeometry(tex.worldWidth, tex.worldHeight);
+  const planeMaterial = new MeshBasicMaterial({
+    map: tex.texture,
+    transparent: true,
+    depthWrite: false
+  });
+  const plane = new Mesh(planeGeo, planeMaterial);
+  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);
+  group.add(plane);
+  disposables.push(planeGeo, planeMaterial, tex.texture);
+}
+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);
+  }
+}
+function buildMeshGroup(model) {
+  const group = new Group();
+  const disposables = [];
+  for (const m of model.meshes) {
+    addBlock(group, disposables, m);
+    addLabel(group, disposables, m);
+  }
+  addConnectors(group, disposables, model);
+  return {
+    group,
+    dispose() {
+      for (const d of disposables) {
+        d.dispose();
+      }
+    }
+  };
+}
+var FOV = 42;
+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, r) => {
+    minX = Math.min(minX, x - r);
+    minY = Math.min(minY, y - r);
+    minZ = Math.min(minZ, z - r);
+    maxX = Math.max(maxX, x + r);
+    maxY = Math.max(maxY, y + r);
+    maxZ = Math.max(maxZ, z + r);
+  };
+  for (const m of model.meshes) {
+    const r = Math.max(m.halfWidth, m.halfHeight) + m.depth + m.bevel;
+    expand(m.position.x, m.position.y, m.position.z, r);
+  }
+  for (const c of model.connectors) {
+    for (const p of c.points) {
+      expand(p.x, p.y, p.z, 1);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    const fallback = Math.max(model.bounds.width, model.bounds.height) / 2 || 1;
+    return { cx: 0, cy: 0, cz: 0, radius: fallback };
+  }
+  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
+  };
+}
+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;
+}
+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 { cx, cy, cz, radius } = contentSphere(model);
+  const aspect = width / Math.max(1, height);
+  const dist = frameDistance(radius, aspect);
+  const camera = new PerspectiveCamera(FOV, aspect, 0.1, dist * 8 + radius * 4);
+  camera.position.set(cx + radius * 0.25, cy + radius * 0.3, cz + dist);
+  camera.lookAt(cx, cy, cz);
+  scene.add(new AmbientLight(16777215, 0.62));
+  const key = new DirectionalLight(16777215, 0.95);
+  key.position.set(cx + radius, cy + radius * 1.4, cz + dist);
+  scene.add(key);
+  const fill = new DirectionalLight(16777215, 0.3);
+  fill.position.set(cx - radius, cy - radius * 0.6, cz + dist * 0.6);
+  scene.add(fill);
+  const built = buildMeshGroup(model);
+  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);
+    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);
+    },
+    dispose() {
+      disposed = true;
+      cancelAnimationFrame(frame);
+      controls?.dispose();
+      built.dispose();
+      renderer.dispose();
+    }
+  };
+}
+function SmartArt3DScene({
+  model,
+  width,
+  height,
+  interactive
+}) {
+  const canvasRef = useRef(null);
+  const handleRef = useRef(null);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) {
+      return;
+    }
+    const handle = mountSmartArt3D(canvas, model, width, height, {
+      interactive
+    });
+    handleRef.current = handle;
+    return () => {
+      handle.dispose();
+      handleRef.current = null;
+    };
+  }, [model]);
+  useEffect(() => {
+    handleRef.current?.resize(width, height);
+  }, [width, height]);
+  useEffect(() => {
+    handleRef.current?.setInteractive(interactive);
+  }, [interactive]);
+  return /* @__PURE__ */ jsx(
+    "canvas",
+    {
+      ref: canvasRef,
+      style: { width, height, display: "block", pointerEvents: interactive ? "auto" : "none" }
+    }
+  );
+}
+
+export { SmartArt3DScene as default };