@supersoniks/concorde 4.9.98-visual-stack.1 → 5.0.1

package/src/core/components/functional/3d/frame-capture.ts

@@ -1,135 +0,0 @@
-import { revokeMediaUrls } from "@supersoniks/concorde/core/utils/mediaRef";
-import {
-  DEFAULT_SNAPSHOT_INTERVAL_MS,
-  MIN_SNAPSHOT_INTERVAL_MS,
-  SNAPSHOT_JPEG_MIME,
-  SNAPSHOT_JPEG_QUALITY,
-} from "./constants";
-import { publisherFieldHasListener } from "./publisher-listen";
-import type { Sonic3dSnapshot } from "./types";
-
-export type FrameCaptureHost = {
-  outPublisher: {
-    _proxies_?: Map<string, { hasListener?: () => boolean }>;
-  } | null;
-  runtime: {
-    renderer: { domElement: HTMLCanvasElement };
-  } | null;
-  snapshotInterval: number;
-  frameOut: boolean;
-  snapshotBusy: boolean;
-  lastSnapshotAt: number;
-  frameUrls: string[];
-  snapshotSeq: number;
-};
-
-const FRAME_KEYS = ["frameUrl", "snapshot"] as const;
-
-function wantsFrameCapture(host: FrameCaptureHost): boolean {
-  if (!host.outPublisher) return false;
-  if (host.frameOut) return true;
-  for (const key of FRAME_KEYS) {
-    if (publisherFieldHasListener(host.outPublisher, key)) return true;
-  }
-  return false;
-}
-
-function mediaFromBlob(
-  canvas: HTMLCanvasElement,
-  blob: Blob,
-): Sonic3dSnapshot {
-  const url = URL.createObjectURL(blob);
-  return {
-    url,
-    blob,
-    width: canvas.width,
-    height: canvas.height,
-    mime: blob.type || SNAPSHOT_JPEG_MIME,
-  };
-}
-
-function canvasToMedia(
-  canvas: HTMLCanvasElement,
-): Promise<Sonic3dSnapshot | null> {
-  return new Promise((resolve) => {
-    if (typeof canvas.toBlob !== "function") {
-      resolve(null);
-      return;
-    }
-    const onBlob = (blob: Blob | null) => {
-      if (!blob) {
-        resolve(null);
-        return;
-      }
-      resolve(mediaFromBlob(canvas, blob));
-    };
-    try {
-      canvas.toBlob(onBlob, SNAPSHOT_JPEG_MIME, SNAPSHOT_JPEG_QUALITY);
-    } catch {
-      resolve(null);
-    }
-  });
-}
-
-function writeFrameFields(host: FrameCaptureHost, media: Sonic3dSnapshot) {
-  const pub = host.outPublisher as Record<
-    string,
-    { set: (v: unknown) => void }
-  > | null;
-  if (!pub) return;
-  try {
-    pub.frameUrl.set(media.url);
-  } catch {
-    /* leaf manquant */
-  }
-  try {
-    pub.snapshot.set(media);
-  } catch {
-    /* leaf manquant */
-  }
-}
-
-/**
- * Si un consommateur écoute `frameUrl` / `snapshot`, capture le canvas
- * (throttlé, async). Révoque l’ObjectURL précédent.
- */
-function maybeCapture(host: FrameCaptureHost, now: number) {
-  if (host.snapshotBusy) return;
-  if (!host.runtime) return;
-  if (!wantsFrameCapture(host)) return;
-  const interval = Math.max(
-    MIN_SNAPSHOT_INTERVAL_MS,
-    Number.isFinite(host.snapshotInterval) && host.snapshotInterval > 0
-      ? host.snapshotInterval
-      : DEFAULT_SNAPSHOT_INTERVAL_MS,
-  );
-  if (now - host.lastSnapshotAt < interval) return;
-  host.lastSnapshotAt = now;
-  host.snapshotBusy = true;
-  const seq = ++host.snapshotSeq;
-  const canvas = host.runtime.renderer.domElement;
-  void canvasToMedia(canvas).then((media) => {
-    host.snapshotBusy = false;
-    if (!media || seq !== host.snapshotSeq) {
-      if (media) revokeMediaUrls([media.url]);
-      return;
-    }
-    revokeMediaUrls(host.frameUrls);
-    host.frameUrls = [media.url];
-    writeFrameFields(host, media);
-  });
-}
-
-function revokeAll(host: FrameCaptureHost) {
-  host.snapshotSeq++;
-  host.snapshotBusy = false;
-  revokeMediaUrls(host.frameUrls);
-  host.frameUrls = [];
-}
-
-export const frameCapture = {
-  wantsFrameCapture,
-  maybeCapture,
-  revokeAll,
-  FRAME_KEYS,
-} as const;

package/src/core/components/functional/3d/frame-source.ts

@@ -1,30 +0,0 @@
-import { publisherFieldHasListener } from "./publisher-listen";
-
-type OutPublisherLike = {
-  _proxies_?: Map<string, { hasListener?: () => boolean }>;
-  frameSource?: { set: (v: unknown) => void };
-};
-
-export type FrameSourceHost = {
-  outPublisher: OutPublisherLike | null;
-  bindOutPublisher: () => void;
-  ready: boolean;
-};
-
-/**
- * Publie `{ element: host }` une fois au ready si un lecteur écoute `frameSource`.
- * Aucun coût pendant l’animation.
- */
-function maybePublish(host: FrameSourceHost & Element) {
-  if (!host.ready) return;
-  if (!host.outPublisher) host.bindOutPublisher();
-  const pub = host.outPublisher;
-  if (!pub || !publisherFieldHasListener(pub, "frameSource")) return;
-  try {
-    pub.frameSource?.set({ element: host });
-  } catch {
-    /* leaf manquant */
-  }
-}
-
-export const frameSource = { maybePublish } as const;

package/src/core/components/functional/3d/gl.ts

@@ -1,35 +0,0 @@
-import * as THREE from "three";
-
-const WEBGL_UNAVAILABLE_MSG =
-  "WebGL indisponible — sonic-3d nécessite WebGL.";
-
-/** Crée un WebGLRenderer ou lève si WebGL indisponible (jsdom / GPU). */
-export function createRenderer(canvas: HTMLCanvasElement): THREE.WebGLRenderer {
-  const probe = document.createElement("canvas");
-  const gl = probe.getContext("webgl2") || probe.getContext("webgl");
-  if (!gl || typeof (gl as WebGLRenderingContext).getParameter !== "function") {
-    throw new Error(WEBGL_UNAVAILABLE_MSG);
-  }
-  const rendererOpts = {
-    canvas,
-    antialias: true,
-    alpha: false,
-    /**
-     * Requis pour `toBlob` / snapshot async après `render()` (pont shader via DP).
-     */
-    preserveDrawingBuffer: true,
-    powerPreference: "high-performance" as const,
-  };
-  let renderer: THREE.WebGLRenderer;
-  try {
-    renderer = new THREE.WebGLRenderer(rendererOpts);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`${WEBGL_UNAVAILABLE_MSG} (${msg})`);
-  }
-  if (!renderer.getContext()) {
-    renderer.dispose();
-    throw new Error(WEBGL_UNAVAILABLE_MSG);
-  }
-  return renderer;
-}

package/src/core/components/functional/3d/life.ts

@@ -1,104 +0,0 @@
-import { PublisherManager } from "@supersoniks/concorde/utils";
-import { ensure } from "./ensure";
-import { formBind } from "./form-bind";
-import { wantsOffscreenPlay } from "./playback";
-import type { SceneRuntime } from "./runtime";
-
-/** Host Lit pour cycle de vie / observers / bind DP. */
-export type LifeHost = {
-  aspectRatio: string;
-  dataProvider: string;
-  outDataProvider: string;
-  releaseOffscreen: boolean;
-  playOffscreen: boolean;
-  frameConsumerCount: number;
-  inView: boolean;
-  runtime: SceneRuntime | null;
-  camera: string;
-  fov: number;
-  exposure: number;
-  dprMax: number;
-  fit: boolean;
-  minDistance: number;
-  maxDistance: number;
-  minPolar: number;
-  maxPolar: number;
-  style: CSSStyleDeclaration;
-  formPublisher: ReturnType<typeof PublisherManager.get> | null;
-  outPublisher: ReturnType<typeof PublisherManager.get> | null;
-  resizeObserver: ResizeObserver | null;
-  intersectionObserver: IntersectionObserver | null;
-  onFormMutation: () => void;
-  syncPlayback: () => void;
-};
-
-function applyAspectRatio(host: LifeHost) {
-  const forced = host.aspectRatio.trim();
-  if (forced) {
-    host.style.setProperty(
-      "--sonic-3d-ar",
-      forced.includes("/") ? forced : forced.replace(":", " / "),
-    );
-    return;
-  }
-  host.style.removeProperty("--sonic-3d-ar");
-}
-
-function unbindFormProvider(host: LifeHost) {
-  if (host.formPublisher) {
-    host.formPublisher.offInternalMutation(host.onFormMutation);
-    host.formPublisher = null;
-  }
-}
-
-function bindFormProvider(host: LifeHost) {
-  unbindFormProvider(host);
-  const id = formBind.resolveFormProviderId(
-    host as unknown as HTMLElement,
-    host.dataProvider,
-  );
-  if (!id) return;
-  host.formPublisher = PublisherManager.get(id);
-  host.formPublisher.onInternalMutation(host.onFormMutation);
-  host.onFormMutation();
-}
-
-function bindOutPublisher(host: LifeHost) {
-  const id = formBind.resolveOutProviderId(
-    host as unknown as HTMLElement,
-    host.outDataProvider,
-    host.dataProvider,
-  );
-  host.outPublisher = id ? PublisherManager.get(id) : null;
-}
-
-function firstUpdated(host: LifeHost) {
-  applyAspectRatio(host);
-  host.resizeObserver = new ResizeObserver(() =>
-    ensure.syncSize(host as never),
-  );
-  host.resizeObserver.observe(host as unknown as Element);
-  host.intersectionObserver = new IntersectionObserver(
-    (entries) => {
-      host.inView = entries.some((e) => e.isIntersecting);
-      ensure.syncVisibility(host as never);
-    },
-    { threshold: 0 },
-  );
-  host.intersectionObserver.observe(host as unknown as Element);
-  bindFormProvider(host);
-  bindOutPublisher(host);
-  requestAnimationFrame(() => {
-    if (host.inView || !host.releaseOffscreen || wantsOffscreenPlay(host)) {
-      void ensure.ensureRuntime(host as never);
-    }
-  });
-}
-
-export const life = {
-  applyAspectRatio,
-  unbindFormProvider,
-  bindFormProvider,
-  bindOutPublisher,
-  firstUpdated,
-} as const;

package/src/core/components/functional/3d/load.ts

@@ -1,129 +0,0 @@
-import * as THREE from "three";
-import type { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
-import { parse } from "./parse";
-import type { Sonic3dAsset } from "./types";
-import { demoContent } from "./demo-content";
-import { pick, type HighlightCtx } from "./pick";
-
-export type LoadCtx = HighlightCtx & {
-  root: THREE.Group;
-  content: THREE.Object3D | null;
-  bbox: THREE.Box3;
-  blobUrl: string | null;
-  loader: GLTFLoader;
-  fitEnabled: boolean;
-  fitToContent: () => void;
-};
-
-function revokeBlob(ctx: { blobUrl: string | null }) {
-  if (ctx.blobUrl) {
-    try {
-      URL.revokeObjectURL(ctx.blobUrl);
-    } catch {
-      /* ignore */
-    }
-    ctx.blobUrl = null;
-  }
-}
-
-function clearContent(ctx: LoadCtx) {
-  pick.clearHighlight(ctx);
-  if (!ctx.content) return;
-  ctx.root.remove(ctx.content);
-  ctx.content.traverse((obj: THREE.Object3D) => {
-    const mesh = obj as THREE.Mesh;
-    if (mesh.isMesh) {
-      mesh.geometry?.dispose();
-      const mats = Array.isArray(mesh.material)
-        ? mesh.material
-        : [mesh.material];
-      for (const m of mats) m?.dispose?.();
-    }
-  });
-  ctx.content = null;
-  ctx.bbox.makeEmpty();
-}
-
-function updateBBox(ctx: LoadCtx) {
-  ctx.bbox.makeEmpty();
-  if (ctx.content) ctx.bbox.setFromObject(ctx.content);
-}
-
-function applyMorphTargets(
-  root: THREE.Object3D,
-  weights: Record<string, number>,
-) {
-  root.traverse((obj: THREE.Object3D) => {
-    const mesh = obj as THREE.Mesh;
-    if (!mesh.isMesh || !mesh.morphTargetDictionary || !mesh.morphTargetInfluences)
-      return;
-    for (const [name, w] of Object.entries(weights)) {
-      const idx = mesh.morphTargetDictionary[name];
-      if (idx !== undefined) {
-        mesh.morphTargetInfluences[idx] = w;
-      }
-    }
-  });
-}
-
-/**
- * Charge un asset (URL / blob) ou affiche le cube de démo si vide.
- * Retourne `{ ready, error }` ; lève si load échoue après fallback démo.
- */
-async function asset(
-  ctx: LoadCtx,
-  asset: Sonic3dAsset | null,
-  token: number,
-  isCurrent: (t: number) => boolean,
-): Promise<{ ready: boolean; error: string | null }> {
-  clearContent(ctx);
-
-  try {
-    let url = asset?.url?.trim() ?? "";
-    if (!url && asset?.blob) {
-      revokeBlob(ctx);
-      ctx.blobUrl = URL.createObjectURL(asset.blob);
-      url = ctx.blobUrl;
-    }
-
-    if (!url) {
-      ctx.content = demoContent.create();
-      ctx.root.add(ctx.content);
-    } else {
-      const kind = asset?.kind ?? parse.guessKind(url);
-      if (kind === "obj" || kind === "ply") {
-        throw new Error(
-          `Format "${kind}" non supporté en V1 — utilisez glTF/GLB.`,
-        );
-      }
-      const gltf = await ctx.loader.loadAsync(url);
-      if (!isCurrent(token)) return { ready: false, error: null };
-      ctx.content = gltf.scene;
-      ctx.root.add(ctx.content);
-      if (asset?.morphTargets) {
-        applyMorphTargets(ctx.content, asset.morphTargets);
-      }
-    }
-
-    if (!isCurrent(token)) return { ready: false, error: null };
-    updateBBox(ctx);
-    if (ctx.fitEnabled) ctx.fitToContent();
-    return { ready: true, error: null };
-  } catch (err) {
-    if (!isCurrent(token)) return { ready: false, error: null };
-    const error = err instanceof Error ? err.message : String(err);
-    ctx.content = demoContent.create();
-    ctx.root.add(ctx.content);
-    updateBBox(ctx);
-    if (ctx.fitEnabled) ctx.fitToContent();
-    throw err instanceof Error ? err : new Error(error);
-  }
-}
-
-export const load = {
-  asset,
-  applyMorphTargets,
-  clearContent,
-  updateBBox,
-  revokeBlob,
-} as const;

package/src/core/components/functional/3d/ops.ts

@@ -1,126 +0,0 @@
-import type * as THREE from "three";
-import { load, type LoadCtx } from "./load";
-import { orbit } from "./orbit";
-import { pick, type HighlightCtx, type SceneHit } from "./pick";
-import { snapshot } from "./snapshot";
-import type { Sonic3dAsset, Sonic3dOutput } from "./types";
-import type { Sonic3dCameraMode } from "./constants";
-import type { OrbitControls } from "three/addons/controls/OrbitControls.js";
-import type { OrbitLimits } from "./orbit";
-
-export type OpsCtx = HighlightCtx &
-  LoadCtx & {
-    loadToken: number;
-    _ready: boolean;
-    _loading: boolean;
-    lastError: string | null;
-    lights: THREE.Light[];
-    scene: THREE.Scene;
-    renderer: THREE.WebGLRenderer;
-    controls: OrbitControls | null;
-    bbox: THREE.Box3;
-    target: THREE.Vector3;
-    mode: Sonic3dCameraMode;
-    fov: number;
-    perspCam: THREE.PerspectiveCamera;
-    orthoCam: THREE.OrthographicCamera;
-    activeCam: THREE.Camera;
-    limits: OrbitLimits;
-    unbindWheelRelay: (() => void) | null;
-  };
-
-async function runLoad(
-  ctx: OpsCtx,
-  asset: Sonic3dAsset | null,
-): Promise<void> {
-  const token = ++ctx.loadToken;
-  ctx._loading = true;
-  ctx._ready = false;
-  ctx.lastError = null;
-  try {
-    const result = await load.asset(
-      ctx,
-      asset,
-      token,
-      (t) => t === ctx.loadToken,
-    );
-    if (token !== ctx.loadToken) return;
-    ctx._ready = result.ready;
-    ctx._loading = false;
-  } catch (err) {
-    if (token !== ctx.loadToken) return;
-    ctx._loading = false;
-    ctx._ready = false;
-    ctx.lastError = err instanceof Error ? err.message : String(err);
-    throw err;
-  }
-}
-
-function fitToContent(ctx: OpsCtx) {
-  orbit.fitToContent({
-    bbox: ctx.bbox,
-    target: ctx.target,
-    activeCam: ctx.activeCam,
-    controls: ctx.controls,
-    mode: ctx.mode,
-    fov: ctx.fov,
-    perspCam: ctx.perspCam,
-    orthoCam: ctx.orthoCam,
-  });
-}
-
-function buildSnapshot(
-  ctx: OpsCtx,
-  base: {
-    time: number;
-    frame: number;
-    hovering: number;
-    pointerX: number;
-    pointerY: number;
-    hit?: SceneHit | null;
-  },
-): Sonic3dOutput {
-  return snapshot.build(
-    {
-      activeCam: ctx.activeCam,
-      controls: ctx.controls,
-      target: ctx.target,
-      mode: ctx.mode,
-      perspCam: ctx.perspCam,
-      orthoCam: ctx.orthoCam,
-      bbox: ctx.bbox,
-      ready: ctx._ready,
-      loading: ctx._loading,
-    },
-    base,
-  );
-}
-
-function dispose(ctx: OpsCtx, loseContext = false) {
-  ctx.loadToken++;
-  ctx.unbindWheelRelay?.();
-  ctx.unbindWheelRelay = null;
-  ctx.controls?.dispose();
-  ctx.controls = null;
-  load.clearContent(ctx);
-  load.revokeBlob(ctx);
-  for (const light of ctx.lights) ctx.scene.remove(light);
-  ctx.lights = [];
-  ctx.renderer.dispose();
-  if (loseContext) {
-    const ext = ctx.renderer.getContext()?.getExtension?.("WEBGL_lose_context");
-    ext?.loseContext?.();
-  }
-  ctx._ready = false;
-}
-
-export const ops = {
-  runLoad,
-  fitToContent,
-  buildSnapshot,
-  dispose,
-  pick: (ctx: HighlightCtx, x: number, y: number) => pick.hit(ctx, x, y),
-  setHoverAt: (ctx: HighlightCtx, x: number, y: number) =>
-    pick.setHoverAt(ctx, x, y),
-  clearHighlight: (ctx: HighlightCtx) => pick.clearHighlight(ctx),
-} as const;

package/src/core/components/functional/3d/opts.ts

@@ -1,16 +0,0 @@
-import type { Sonic3dCameraMode } from "./constants";
-
-export type SceneRuntimeOptions = {
-  canvas: HTMLCanvasElement;
-  dprMax?: number;
-  camera?: Sonic3dCameraMode;
-  fov?: number;
-  exposure?: number;
-  autoRotate?: boolean;
-  fit?: boolean;
-  minDistance?: number;
-  maxDistance?: number;
-  /** Polar angles in radians. */
-  minPolar?: number;
-  maxPolar?: number;
-};