@ifc-lite/viewer 1.23.0 → 1.25.0

package/src/hooks/useForkExtension.ts

@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * `useForkExtension` — wraps the fork-an-installed-extension flow.
+ *
+ * Looks up the bundle from the loader, formats it as a chat-prompt
+ * fenced bundle via `formatBundleForPrompt`, queues the prompt and
+ * opens the chat. Pure side-effects; UI calls `fork(id)` and reacts
+ * to toasts.
+ */
+
+import { useCallback } from 'react';
+import { formatBundleForPrompt } from '@ifc-lite/extensions';
+import { useExtensionHost } from '@/sdk/ExtensionHostProvider';
+import { useViewerStore } from '@/store';
+import { toast } from '@/components/ui/toast';
+import * as toastText from '@/components/extensions/toast-helpers';
+
+export function useForkExtension(): (id: string) => void {
+  const host = useExtensionHost();
+  const queueChatPrompt = useViewerStore((s) => s.queueChatPrompt);
+  const setChatPanelVisible = useViewerStore((s) => s.setChatPanelVisible);
+
+  return useCallback(
+    (id: string) => {
+      try {
+        const bundle = host.loader.getBundle(id);
+        if (!bundle) {
+          toast.error(`Bundle for ${id} not loaded.`);
+          return;
+        }
+        const formatted = formatBundleForPrompt(bundle);
+        const prompt = [
+          `Fork the installed extension ${bundle.manifest.id} (v${bundle.manifest.version}).`,
+          '',
+          formatted.text,
+          '',
+          'What would you like to change?',
+        ].join('\n');
+        queueChatPrompt(prompt);
+        setChatPanelVisible(true);
+        toast.success(`Routed ${bundle.manifest.id} to chat for editing`);
+      } catch (err) {
+        toast.error(toastText.failed('Fork', err));
+      }
+    },
+    [host, queueChatPrompt, setChatPanelVisible],
+  );
+}

package/src/hooks/useIfcFederation.ts

@@ -908,7 +908,13 @@ export function useIfcFederation() {
       // top-level fields. When subsequent models are added, activeModelId
       // stays on the first model — writing here would alias the new model's
       // data into the active (first) model's per-model entry and cause both
-      // viewport slots to render the same mesh (issue #661).
+      // viewport slots to render the same mesh (issue #661, PR #792).
+      //
+      // An earlier draft of this branch called `setActiveModel(modelId)`
+      // here, which also fixed #661 but had the side-effect of stealing
+      // focus to every added model — confusing UX. The main-branch fix
+      // (drop the legacy calls; keep activeModelId on the first model)
+      // is preferred and was kept on merge.
 
       setProgress({ phase: 'Complete', percent: 100 });
       setLoading(false);

package/src/hooks/useInstalledExtensions.ts

@@ -0,0 +1,43 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { useEffect, useState } from 'react';
+import type { InstalledExtensionRecord } from '@ifc-lite/extensions';
+import { useOptionalExtensionHost } from '@/sdk/ExtensionHostProvider.js';
+
+/**
+ * Live list of installed extensions. Refreshes whenever the host
+ * service's "anything changed" signal fires (install/uninstall/
+ * enable/disable).
+ */
+export function useInstalledExtensions(): InstalledExtensionRecord[] {
+  const host = useOptionalExtensionHost();
+  const [records, setRecords] = useState<InstalledExtensionRecord[]>([]);
+
+  useEffect(() => {
+    if (!host) {
+      setRecords([]);
+      return;
+    }
+    let cancelled = false;
+    const refresh = async () => {
+      try {
+        const next = await host.listInstalled();
+        if (!cancelled) setRecords(next);
+      } catch (err) {
+        console.error('[useInstalledExtensions] listInstalled failed:', err);
+      }
+    };
+    void refresh();
+    const off = host.onChange(() => {
+      void refresh();
+    });
+    return () => {
+      cancelled = true;
+      off();
+    };
+  }, [host]);
+
+  return records;
+}

package/src/hooks/usePrivacyDisclosure.ts

@@ -0,0 +1,48 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * `usePrivacyDisclosure` — show the privacy disclosure once per browser.
+ *
+ * Fires a one-time toast on first launch after the extensions
+ * subsystem (action log + miner) is alive. Persists the
+ * acknowledgement under a localStorage flag so users only see the
+ * disclosure once. The toast points at the Privacy panel for the
+ * full controls.
+ *
+ * The disclosure is required by RFC §06 §7 — users must be told what
+ * gets stored locally before the miner / memory loops start.
+ */
+
+import { useEffect } from 'react';
+import { toast } from '@/components/ui/toast';
+import { useOptionalExtensionHost } from '@/sdk/ExtensionHostProvider';
+
+const STORAGE_KEY = 'ifclite.extensions.privacy-disclosure.v1';
+
+export function usePrivacyDisclosure(): void {
+  const host = useOptionalExtensionHost();
+  useEffect(() => {
+    if (!host) return;
+    if (typeof window === 'undefined') return;
+    try {
+      if (window.localStorage.getItem(STORAGE_KEY)) return;
+    } catch {
+      // Privacy modes can block localStorage — skip silently.
+      return;
+    }
+    // Defer slightly so the toast doesn't fight with the splash UI.
+    const handle = window.setTimeout(() => {
+      toast.info(
+        'IFClite keeps a local, content-free action log to suggest one-click tools. Manage or delete it in Extensions → Privacy.',
+      );
+      try {
+        window.localStorage.setItem(STORAGE_KEY, new Date().toISOString());
+      } catch {
+        // Best effort — re-firing on every load is annoying but not harmful.
+      }
+    }, 3500);
+    return () => window.clearTimeout(handle);
+  }, [host]);
+}

package/src/hooks/useRunExtensionTests.ts

@@ -0,0 +1,67 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * `useRunExtensionTests` — wraps the per-extension test run.
+ *
+ * Tracks a per-id "running" set so repeated clicks don't queue
+ * concurrent runs. The UI uses `isRunning(id)` to gate the trigger
+ * button + show a pulsing icon.
+ *
+ * Returns `{ runTests, isRunning }`.
+ */
+
+import { useCallback, useState } from 'react';
+import { useExtensionHost } from '@/sdk/ExtensionHostProvider';
+import { toast } from '@/components/ui/toast';
+import * as toastText from '@/components/extensions/toast-helpers';
+
+export interface RunExtensionTestsApi {
+  runTests(id: string): void;
+  isRunning(id: string): boolean;
+}
+
+export function useRunExtensionTests(): RunExtensionTestsApi {
+  const host = useExtensionHost();
+  const [running, setRunning] = useState<ReadonlySet<string>>(new Set());
+
+  const runTests = useCallback(
+    (id: string) => {
+      if (running.has(id)) return;
+      setRunning((prev) => {
+        const next = new Set(prev);
+        next.add(id);
+        return next;
+      });
+      toast.info(`Running tests for ${id}…`);
+      host.runTests(id)
+        .then((summary) => {
+          if (summary.results.length === 0) {
+            toast.info(toastText.testsNotDeclared(id));
+          } else if (summary.failed === 0) {
+            toast.success(toastText.testsPassed(id, summary.passed, summary.results.length));
+          } else {
+            const firstError = summary.results.find((r) => !r.passed)?.error ?? 'see console';
+            toast.error(toastText.testsFailed(id, summary.failed, firstError));
+            console.warn('[ext-host] test failures:', summary);
+          }
+        })
+        .catch((err) => {
+          toast.error(toastText.failed(`Tests for ${id}`, err));
+        })
+        .finally(() => {
+          setRunning((prev) => {
+            const next = new Set(prev);
+            next.delete(id);
+            return next;
+          });
+        });
+    },
+    [host, running],
+  );
+
+  const isRunning = useCallback((id: string) => running.has(id), [running]);
+
+  return { runTests, isRunning };
+}

package/src/hooks/useSlotContributions.ts

@@ -0,0 +1,38 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Subscribe a React component to a slot in the extension SlotRegistry.
+ *
+ * Re-renders whenever an extension registers or unregisters
+ * contributions for the named slot. Returns the current list,
+ * snapshot-style, in registration order.
+ */
+
+import { useEffect, useState } from 'react';
+import type { SlotContribution } from '@ifc-lite/extensions';
+import { useOptionalExtensionHost } from '@/sdk/ExtensionHostProvider.js';
+
+export function useSlotContributions<T = unknown>(slot: string): SlotContribution<T>[] {
+  const host = useOptionalExtensionHost();
+  const [items, setItems] = useState<SlotContribution<T>[]>(
+    () => host?.getSlotContributions<T>(slot) ?? [],
+  );
+
+  useEffect(() => {
+    if (!host) {
+      setItems([]);
+      return;
+    }
+    // Refresh snapshot synchronously before subscribing — otherwise
+    // switching slots can leave old contributions visible until the
+    // next registry event arrives.
+    setItems(host.getSlotContributions<T>(slot));
+    return host.subscribeSlot<T>(slot, (next) => {
+      setItems(next);
+    });
+  }, [host, slot]);
+
+  return items;
+}

package/src/hooks/useSymbolicAnnotations.test.ts

@@ -0,0 +1,124 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Unit tests for the symbolic-annotation segment helpers.
+ *
+ * The full React hook is exercised at integration time (covered by the
+ * #653 manual smoke test); here we lock in the geometry conversion that
+ * turns WASM-returned polylines/arcs into DrawingLine2D pairs.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import type { DrawingLine2D } from '@ifc-lite/renderer';
+import { polylineToSegments, circleToSegments, liftTo3DLineList } from './useSymbolicAnnotations.js';
+
+describe('polylineToSegments', () => {
+  it('emits N-1 segments for an open polyline', () => {
+    // 3 points -> 2 segments
+    const points = new Float32Array([0, 0, 1, 0, 1, 1]);
+    const out: DrawingLine2D[] = [];
+    polylineToSegments(points, 3, false, out);
+    assert.equal(out.length, 2);
+    assert.deepEqual(out[0].line.start, { x: 0, y: 0 });
+    assert.deepEqual(out[0].line.end, { x: 1, y: 0 });
+    assert.deepEqual(out[1].line.start, { x: 1, y: 0 });
+    assert.deepEqual(out[1].line.end, { x: 1, y: 1 });
+    assert.equal(out[0].category, 'annotation');
+  });
+
+  it('adds a closing segment when isClosed is true', () => {
+    const points = new Float32Array([0, 0, 2, 0, 2, 2]);
+    const out: DrawingLine2D[] = [];
+    polylineToSegments(points, 3, true, out);
+    // 2 open + 1 closing = 3
+    assert.equal(out.length, 3);
+    assert.deepEqual(out[2].line.start, { x: 2, y: 2 });
+    assert.deepEqual(out[2].line.end, { x: 0, y: 0 });
+  });
+
+  it('skips the closing segment for two-point polylines even when isClosed', () => {
+    const points = new Float32Array([0, 0, 1, 0]);
+    const out: DrawingLine2D[] = [];
+    polylineToSegments(points, 2, true, out);
+    assert.equal(out.length, 1);
+  });
+
+  it('appends to an existing output array without clearing it', () => {
+    const points = new Float32Array([0, 0, 1, 0]);
+    const out: DrawingLine2D[] = [
+      { line: { start: { x: 9, y: 9 }, end: { x: 8, y: 8 } }, category: 'preset' },
+    ];
+    polylineToSegments(points, 2, false, out);
+    assert.equal(out.length, 2);
+    assert.equal(out[0].category, 'preset');
+    assert.equal(out[1].category, 'annotation');
+  });
+});
+
+describe('circleToSegments', () => {
+  it('tessellates a full circle into 32 segments', () => {
+    const out: DrawingLine2D[] = [];
+    circleToSegments(0, 0, 1, 0, Math.PI * 2, true, out);
+    assert.equal(out.length, 32);
+  });
+
+  it('tessellates an arc into 16 segments', () => {
+    const out: DrawingLine2D[] = [];
+    circleToSegments(0, 0, 1, 0, Math.PI, false, out);
+    assert.equal(out.length, 16);
+  });
+
+  it('places points on the circle within numerical tolerance', () => {
+    const out: DrawingLine2D[] = [];
+    circleToSegments(5, 7, 3, 0, Math.PI * 2, true, out);
+    for (const seg of out) {
+      const dx = seg.line.start.x - 5;
+      const dy = seg.line.start.y - 7;
+      const r = Math.sqrt(dx * dx + dy * dy);
+      assert.ok(Math.abs(r - 3) < 1e-5, `expected radius 3, got ${r}`);
+    }
+  });
+
+  it('marks output with category "annotation"', () => {
+    const out: DrawingLine2D[] = [];
+    circleToSegments(0, 0, 1, 0, Math.PI / 2, false, out);
+    assert.ok(out.every((seg) => seg.category === 'annotation'));
+  });
+});
+
+describe('liftTo3DLineList', () => {
+  it('emits six floats per segment with the storey Y in the middle slot', () => {
+    const lines: DrawingLine2D[] = [
+      { line: { start: { x: 1, y: 2 }, end: { x: 3, y: 4 } }, category: 'annotation' },
+      { line: { start: { x: 5, y: 6 }, end: { x: 7, y: 8 } }, category: 'annotation' },
+    ];
+    const out: number[] = [];
+    liftTo3DLineList(lines, 5.45, out);
+    assert.deepEqual(out, [
+      1, 5.45, 2,   3, 5.45, 4,
+      5, 5.45, 6,   7, 5.45, 8,
+    ]);
+  });
+
+  it('appends to an existing output array', () => {
+    const out: number[] = [99, 99, 99];
+    liftTo3DLineList(
+      [{ line: { start: { x: 0, y: 0 }, end: { x: 1, y: 1 } }, category: 'annotation' }],
+      2,
+      out,
+    );
+    assert.equal(out.length, 9);
+    assert.equal(out[0], 99);
+    assert.equal(out[3], 0);
+    assert.equal(out[4], 2);
+  });
+
+  it('does nothing for an empty input', () => {
+    const out: number[] = [];
+    liftTo3DLineList([], 1, out);
+    assert.equal(out.length, 0);
+  });
+});