@nebula-spatial/viewer 0.2.4 → 0.4.0

package/dist/mujoco-runtime-s85kwjo7.js

@@ -0,0 +1,208 @@
+var E = Object.defineProperty;
+var M = (r, t, i) => t in r ? E(r, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[t] = i;
+var p = (r, t, i) => M(r, typeof t != "symbol" ? t + "" : t, i);
+import T from "@mujoco/mujoco";
+import I from "@mujoco/mujoco/mujoco.wasm?url";
+let w = 0;
+function F(r, t) {
+  const i = `/viewer-simulation-${++w}`;
+  r.mkdir(i);
+  const n = /* @__PURE__ */ new Set([i]), o = /* @__PURE__ */ new Set(), a = (e, s) => {
+    const c = e.replaceAll("\\", "/").split("/");
+    if (c[0] === "" || c.some((u) => u === ".." || u.includes(":"))) throw b(`Invalid package path: ${e}`, "E_SIMULATION_PATH");
+    const l = c.filter((u) => u && u !== ".");
+    if (!l.length) throw b("Package path is empty.", "E_SIMULATION_PATH");
+    let m = i;
+    for (const u of l.slice(0, -1))
+      m += `/${u}`, n.has(m) || (r.mkdir(m), n.add(m));
+    const d = `${i}/${l.join("/")}`;
+    return r.writeFile(d, s), o.add(d), d;
+  }, h = () => {
+    for (const e of o) r.unlink(e);
+    o.clear();
+    for (const e of [...n].reverse()) r.rmdir(e);
+    n.clear();
+  };
+  try {
+    for (const [e, s] of t) a(e, s);
+    return { writeEntry: (e) => a("__viewer_entry.xml", e), dispose: h };
+  } catch (e) {
+    throw h(), e;
+  }
+}
+function b(r, t) {
+  return Object.assign(new Error(r), { code: t });
+}
+function O({
+  target: r,
+  point: t,
+  velocity: i,
+  stiffness: n,
+  damping: o,
+  maxForce: a,
+  strength: h
+}) {
+  const e = [
+    n * (r[0] - t[0]) - o * i[0],
+    n * (r[1] - t[1]) - o * i[1],
+    n * (r[2] - t[2]) - o * i[2]
+  ], s = Math.hypot(e[0], e[1], e[2]), c = a * h;
+  if (s > c && s > 0) {
+    const l = c / s;
+    e[0] *= l, e[1] *= l, e[2] *= l;
+  }
+  return e;
+}
+const f = 1 / 240, A = 0.05, v = 80, x = 1.15, g = 3.5, y = 14;
+class C {
+  constructor() {
+    p(this, "mujoco", null);
+    p(this, "model", null);
+    p(this, "data", null);
+    p(this, "grab", null);
+    p(this, "lastGrabForce", [0, 0, 0]);
+    p(this, "velocityBuffer", new Float64Array(6));
+    p(this, "initialControls", []);
+    p(this, "accumulator", 0);
+    p(this, "initialVelocities", []);
+  }
+  async initialize(t, i) {
+    var h;
+    this.mujoco ?? (this.mujoco = await T({ locateFile: (e) => e.endsWith(".wasm") ? i ? new URL(e, i).href : I : e }));
+    const n = F(this.mujoco.FS, t.files);
+    let o = null, a = null;
+    try {
+      o = this.mujoco.MjModel.from_xml_path(n.writeEntry(t.xml));
+      for (const e of t.massOverrides ?? []) {
+        const s = this.mujoco.mj_name2id(o, this.mujoco.mjtObj.mjOBJ_BODY.value, e.body);
+        if (s <= 0 || !Number.isFinite(e.mass) || e.mass <= 0 || !(o.body_mass[s] > 0)) throw new Error(`Invalid mass override: ${e.body}`);
+        const c = e.mass / o.body_mass[s];
+        o.body_mass[s] = e.mass;
+        for (let l = 0; l < 3; l++) o.body_inertia[s * 3 + l] *= c;
+      }
+      a = new this.mujoco.MjData(o), (h = t.massOverrides) != null && h.length && this.mujoco.mj_setConst(o, a), o.opt.timestep = f, this.applyInitialControls(a, t.initialControls), this.applyInitialVelocities(o, a, t.initialVelocities), this.mujoco.mj_forward(o, a);
+    } catch (e) {
+      throw a == null || a.delete(), o == null || o.delete(), _(e, "E_MUJOCO_INITIALIZE");
+    } finally {
+      n.dispose();
+    }
+    this.disposeModel(), this.model = o, this.data = a, this.initialControls = t.initialControls ?? [], this.initialVelocities = t.initialVelocities ?? [], this.accumulator = 0;
+  }
+  beginGrab({
+    bodyId: t,
+    localPoint: i,
+    target: n,
+    stiffness: o = v,
+    damping: a,
+    maxForce: h,
+    dampingRatio: e = x,
+    maxTargetSpeed: s = g,
+    targetResponse: c = y
+  }) {
+    var j;
+    const l = Math.max(((j = this.model) == null ? void 0 : j.body_mass[t]) ?? 1, 1e-3), m = a ?? 2 * Math.sqrt(o * l) * e, d = h ?? Math.max(120, l * 60), u = [n[0], n[1], n[2]];
+    this.grab = {
+      bodyId: t,
+      localPoint: [i[0], i[1], i[2]],
+      target: [...u],
+      requestedTarget: u,
+      stiffness: o,
+      damping: m,
+      maxForce: d,
+      strength: 1,
+      maxTargetSpeed: s,
+      targetResponse: c
+    };
+  }
+  updateGrabTarget(t) {
+    this.grab && (this.grab.requestedTarget = [t[0], t[1], t[2]]);
+  }
+  updateGrabStrength(t) {
+    this.grab && (this.grab.strength = t);
+  }
+  applyGrabForce() {
+    if (!this.grab || !this.model || !this.data || !this.mujoco) return;
+    const { bodyId: t, localPoint: i, target: n, stiffness: o, damping: a, maxForce: h, strength: e } = this.grab, s = this.data.xmat.subarray(t * 9, t * 9 + 9), c = this.data.xpos.subarray(t * 3, t * 3 + 3), l = [
+      c[0] + s[0] * i[0] + s[1] * i[1] + s[2] * i[2],
+      c[1] + s[3] * i[0] + s[4] * i[1] + s[5] * i[2],
+      c[2] + s[6] * i[0] + s[7] * i[1] + s[8] * i[2]
+    ];
+    this.mujoco.mj_objectVelocity(
+      this.model,
+      this.data,
+      this.mujoco.mjtObj.mjOBJ_BODY.value,
+      t,
+      this.velocityBuffer,
+      0
+    );
+    const m = this.velocityBuffer, d = [
+      l[0] - c[0],
+      l[1] - c[1],
+      l[2] - c[2]
+    ], u = [
+      m[3] + m[1] * d[2] - m[2] * d[1],
+      m[4] + m[2] * d[0] - m[0] * d[2],
+      m[5] + m[0] * d[1] - m[1] * d[0]
+    ], j = O({ target: n, point: l, velocity: u, stiffness: o, damping: a, maxForce: h, strength: e });
+    this.lastGrabForce = [...j], this.data.qfrc_applied.fill(0), this.mujoco.mj_applyFT(
+      this.model,
+      this.data,
+      j,
+      [0, 0, 0],
+      l,
+      t,
+      this.data.qfrc_applied
+    );
+  }
+  endGrab() {
+    this.data && this.data.qfrc_applied.fill(0), this.lastGrabForce = [0, 0, 0], this.grab = null;
+  }
+  step(t) {
+    if (!this.mujoco || !this.model || !this.data || t <= 0) return !1;
+    this.accumulator += Math.min(t, A);
+    let i = !1;
+    for (; this.accumulator >= f; )
+      this.updateGrabTargetForStep(), this.applyGrabForce(), this.mujoco.mj_step(this.model, this.data), this.accumulator -= f, i = !0;
+    return i;
+  }
+  updateGrabTargetForStep() {
+    const t = this.grab;
+    if (!t) return;
+    const i = t.requestedTarget ?? t.target, n = (t.maxTargetSpeed ?? g) * Math.max(1, Math.sqrt(t.strength)), o = t.targetResponse ?? y, a = 1 - Math.exp(-o * f), h = n * f;
+    for (let e = 0; e < 3; e++) {
+      const s = i[e] - t.target[e], c = Math.sign(s) * Math.min(Math.abs(s) * a, h);
+      t.target[e] += c;
+    }
+  }
+  reset() {
+    !this.mujoco || !this.model || !this.data || (this.endGrab(), this.mujoco.mj_resetData(this.model, this.data), this.applyInitialControls(this.data, this.initialControls), this.applyInitialVelocities(this.model, this.data, this.initialVelocities), this.mujoco.mj_forward(this.model, this.data), this.accumulator = 0);
+  }
+  dispose() {
+    this.disposeModel(), this.mujoco = null;
+  }
+  applyInitialControls(t, i) {
+    if (i != null && i.length) {
+      if (i.length !== t.ctrl.length) throw _(new Error(`Initial control count ${i.length} does not match MuJoCo actuator count ${t.ctrl.length}.`), "E_MUJOCO_INITIALIZE");
+      t.ctrl.set(i);
+    }
+  }
+  applyInitialVelocities(t, i, n) {
+    for (const o of n ?? []) {
+      const a = this.mujoco.mj_name2id(t, this.mujoco.mjtObj.mjOBJ_BODY.value, o.body), h = a >= 0 ? t.body_jntadr[a] : -1;
+      if (h < 0 || t.jnt_type[h] !== this.mujoco.mjtJoint.mjJNT_FREE.value || o.velocity.length !== 6 || !o.velocity.every(Number.isFinite))
+        throw _(new Error(`Invalid free-body initial velocity: ${o.body}`), "E_MUJOCO_INITIALIZE");
+      i.qvel.set(o.velocity, t.jnt_dofadr[h]);
+    }
+  }
+  disposeModel() {
+    var t, i;
+    this.endGrab(), (t = this.data) == null || t.delete(), (i = this.model) == null || i.delete(), this.data = null, this.model = null, this.initialControls = [], this.initialVelocities = [], this.accumulator = 0;
+  }
+}
+function _(r, t) {
+  const i = r instanceof Error ? r : new Error(String(r));
+  return Object.assign(i, { code: t });
+}
+export {
+  C as MujocoRuntime
+};

package/dist/plugins.d.ts

@@ -0,0 +1,175 @@
+import type { Box3, Object3D } from 'three';
+import type { CadHit, CadSelection, CadViewerSnapshot, CadViewerEventMap } from './cad/types';
+import type { ViewerEventMap, ViewerViewMode, ViewerUiTheme } from './types';
+import type { AssetControlState, AssetLoaderContribution, AssetPreviewSnapshot, AssetUpAxis } from './assets/types';
+export interface Disposable {
+    dispose(): void;
+}
+export interface ToolbarItem {
+    readonly id: string;
+    readonly label: string;
+    readonly title?: string;
+    readonly disabled?: boolean;
+    readonly pressed?: boolean;
+    /** Inline SVG markup (24x24 viewBox, `currentColor` stroke). */
+    readonly icon?: string;
+    readonly onClick: () => void;
+}
+export interface ViewerState {
+    readonly viewMode: ViewerViewMode;
+    readonly selectedObject: Object3D | null;
+    readonly highlightedObject: Object3D | null;
+    readonly isDisposed: boolean;
+}
+/** Read-only view of the active asset. Never exposes the mutable `AssetPreview` handle. */
+export interface ViewerAssetReadApi {
+    /** Snapshot of the active asset; `null` when no asset is open. */
+    $read(): AssetPreviewSnapshot | null;
+    /** Authoritative control state, safe to bind button pressed states to. */
+    $readControl(): AssetControlState;
+}
+export interface ViewerPluginContext {
+    readonly cad: {
+        $read(): CadViewerSnapshot;
+    };
+    readonly asset: ViewerAssetReadApi;
+    readonly viewer: {
+        $getState(): ViewerState;
+    };
+    readonly commands: {
+        setLayerVisible(index: number, visible: boolean): boolean;
+        setSelection(selection: CadSelection | null): void;
+        fitDocument(): boolean;
+        setViewMode(mode: ViewerViewMode): void;
+        play(): boolean;
+        pause(): boolean;
+        reset(): boolean;
+        fitView(): boolean;
+        setUpAxis(axis: AssetUpAxis): boolean;
+        setGroundVisible(visible: boolean): boolean;
+        setCollisionVisible(visible: boolean): boolean;
+        setTheme(theme: ViewerUiTheme): boolean;
+    };
+    readonly events: {
+        on<K extends keyof (ViewerEventMap & CadViewerEventMap)>(type: K, listener: (event: (ViewerEventMap & CadViewerEventMap)[K]) => void): () => void;
+    };
+    readonly layout: {
+        mount(node: Node, options?: {
+            position?: 'left' | 'right' | 'top' | 'bottom' | 'overlay';
+        }): Disposable;
+        onInsetsChange(listener: (insets: ViewerEventMap['ui-layout-change']['contentInsets']) => void): () => void;
+    };
+    contribute(point: ViewerContributionPoint): Disposable;
+    dispose(): void;
+}
+export interface ViewerInteractionHooks {
+    /** Return false to consume the interaction and stop the managed pipeline. */
+    onPick?: (hit: CadHit | null) => boolean | void;
+    onHover?: (hit: CadHit | null) => void;
+    onSelect?: (selection: CadSelection | null) => void;
+    onClear?: () => void;
+}
+export type ViewerContributionPoint = {
+    readonly kind: 'panel';
+    readonly id: string;
+    readonly factory: (ctx: ViewerPluginContext) => Node;
+} | {
+    readonly kind: 'toolbar';
+    readonly id: string;
+    readonly items: readonly ToolbarItem[];
+} | {
+    readonly kind: 'hud';
+    readonly id: string;
+    readonly factory: (ctx: ViewerPluginContext) => Node;
+} | {
+    readonly kind: 'statusbar';
+    readonly id: string;
+    readonly factory: (ctx: ViewerPluginContext) => Node;
+} | {
+    readonly kind: 'inspector';
+    readonly id: string;
+    readonly matcher: (selection: CadSelection) => boolean;
+    readonly render: (ctx: ViewerPluginContext, selection: CadSelection) => Node;
+} | {
+    readonly kind: 'interaction';
+    readonly id: string;
+    readonly hooks: ViewerInteractionHooks;
+} | {
+    readonly kind: 'command';
+    readonly id: string;
+    readonly handler: (ctx: ViewerPluginContext, args?: unknown) => void;
+} | {
+    readonly kind: 'fit-policy';
+    readonly id: string;
+    readonly resolve: (ctx: ViewerPluginContext) => Box3 | null;
+} | AssetLoaderContribution;
+export interface ViewerPlugin {
+    readonly id: string;
+    activate(context: ViewerPluginContext): void | Promise<void>;
+    deactivate?(): void | Promise<void>;
+}
+type SnapshotReader = () => CadViewerSnapshot;
+type StateReader = () => ViewerState;
+type AssetReader = () => AssetPreviewSnapshot | null;
+type ControlStateReader = () => AssetControlState;
+type PluginEventMap = ViewerEventMap & CadViewerEventMap;
+type EventSubscriber = <K extends keyof PluginEventMap>(type: K, listener: (event: PluginEventMap[K]) => void) => () => void;
+type CommandApi = ViewerPluginContext['commands'];
+/**
+ * Layout channel the plugin manager delegates to. The engine owns zone
+ * containers, insets computation and the `ui-layout-change` broadcast; the
+ * manager only forwards contribution nodes into it.
+ */
+export interface PluginLayoutPort {
+    mountPlugin(node: Node, position?: 'left' | 'right' | 'top' | 'bottom' | 'overlay'): Disposable;
+    /** Built-in UI path: the package owns the styling of nodes mounted this way. */
+    mountBuiltin(node: Node, options: {
+        zone: 'left' | 'right' | 'top' | 'bottom' | 'overlay';
+        group?: string;
+    }): Disposable;
+}
+export declare class ViewerPluginManager implements ViewerPluginRegistry {
+    private readonly readCad;
+    private readonly readState;
+    private readonly readAsset;
+    private readonly readControlState;
+    private readonly subscribe;
+    private readonly commands;
+    private readonly hostElement;
+    private readonly layout;
+    private readonly pluginsById;
+    private readonly contributions;
+    private readonly commandContributions;
+    private readonly builtinPlugins;
+    private readonly contributionRemovedListeners;
+    private refreshingInspectors;
+    private disposed;
+    constructor(readCad: SnapshotReader, readState: StateReader, readAsset: AssetReader, readControlState: ControlStateReader, subscribe: EventSubscriber, commands: CommandApi, hostElement: HTMLElement, layout?: PluginLayoutPort | null);
+    register(plugin: ViewerPlugin): Disposable;
+    use(plugins: readonly ViewerPlugin[], options?: {
+        replace?: boolean;
+    }): void;
+    registerBuiltin(plugin: ViewerPlugin): Disposable;
+    getAssetLoaders(): readonly AssetLoaderContribution[];
+    onAssetLoaderRemoved(listener: (loader: AssetLoaderContribution) => void): Disposable;
+    private onContributionRemoved;
+    private deactivate;
+    disposeAll(): void;
+    dispose(): void;
+    dispatchInteraction(kind: keyof ViewerInteractionHooks, value: CadHit | CadSelection | null): boolean;
+    findFitPolicy(): Box3 | null;
+    executeCommand(id: string, args?: unknown): boolean;
+    hasCommand(id: string): boolean;
+    private removeContribution;
+    private mountContribution;
+    private isFirstMatchingInspector;
+    private refreshInspectorContributions;
+    private assertActive;
+}
+export interface ViewerPluginRegistry {
+    register(plugin: ViewerPlugin): Disposable;
+    use(plugins: readonly ViewerPlugin[], options?: {
+        replace?: boolean;
+    }): void;
+}
+export {};