@pascal-app/editor 1.0.0-beta.3 → 1.0.0-beta.5

package/src/lib/structured-clone-fallback.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+
+const native = globalThis.structuredClone
+
+afterEach(() => {
+  globalThis.structuredClone = native
+})
+
+async function installFallback() {
+  // Fresh module instance each time — the shim is a module side effect.
+  await import(`./structured-clone-fallback?${Math.random()}`)
+}
+
+describe('structuredClone fallback', () => {
+  test('leaves a native implementation alone', async () => {
+    await installFallback()
+    expect(globalThis.structuredClone).toBe(native)
+  })
+
+  test('installs a JSON-based clone when the global is missing', async () => {
+    // @ts-expect-error — simulating a browser without the global.
+    globalThis.structuredClone = undefined
+    await installFallback()
+
+    const source = { units: [{ factor: 1, id: 'm' }], kind: 'length' }
+    const copy = structuredClone(source)
+
+    expect(copy).toEqual(source)
+    expect(copy).not.toBe(source)
+    expect(copy.units).not.toBe(source.units)
+  })
+
+  test('lets lingo build its registry without the global', async () => {
+    // @ts-expect-error — simulating a browser without the global.
+    globalThis.structuredClone = undefined
+    await installFallback()
+
+    // The actual regression: lingo clones its kind table at module-eval time,
+    // so this import throws on a browser lacking structuredClone.
+    const { parseQuantity } = await import('@pascal-app/lingo')
+    const result = parseQuantity('180cm', { kind: 'length', unit: 'm' })
+    expect(result.ok).toBe(true)
+    if (result.ok) expect(result.quantity.to('m').value).toBeCloseTo(1.8, 6)
+  })
+})

package/src/lib/structured-clone-fallback.ts

@@ -0,0 +1,24 @@
+/**
+ * `@pascal-app/lingo` builds its unit registry at module-eval time, and
+ * `registerKind` deep-copies each kind definition with `structuredClone`. On a
+ * browser without that global (Chromium <98 — reported from Honor Browser 9.8
+ * as `ReferenceError: structuredClone is not defined`) the throw happens while
+ * the module graph is still evaluating, so a component-level guard can never
+ * run in time and the whole editor bundle fails to load.
+ *
+ * This has to be imported for its side effect from the module that pulls lingo
+ * in, so it is installed wherever `@pascal-app/editor` is loaded — the OSS app,
+ * the hosted app, and any npm consumer. An app-level polyfill would only cover
+ * the app that declares it.
+ *
+ * Scoped deliberately narrowly: the kind definitions lingo clones are plain
+ * JSON (strings, numbers, arrays of those), so a JSON round-trip is sufficient
+ * and avoids a dependency. This is NOT a spec-compliant `structuredClone` — it
+ * has no support for Map/Set/Date/ArrayBuffer/cycles and throws a `TypeError`
+ * rather than a `DataCloneError`. Anything needing real structured-clone
+ * semantics must not rely on this shim.
+ */
+if (typeof globalThis.structuredClone !== 'function') {
+  globalThis.structuredClone = (<T>(value: T): T =>
+    JSON.parse(JSON.stringify(value)) as T) as typeof structuredClone
+}

package/src/store/use-session-groups.ts

@@ -0,0 +1,103 @@
+import { type AnyNodeId, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+import {
+  canCreateSessionGroup,
+  createSessionGroup,
+  expandSessionGroupMembers,
+  type SessionSelectionGroup,
+  selectionIntersectsSessionGroup,
+  selectionMatchesSessionGroup,
+  ungroupSessionSelection,
+} from '../lib/session-groups'
+import { sfxEmitter } from '../lib/sfx-bus'
+
+type SessionGroupsState = {
+  groups: SessionSelectionGroup[]
+  setGroups: (groups: SessionSelectionGroup[]) => void
+  clearGroups: () => void
+}
+
+const useSessionGroups = create<SessionGroupsState>((set) => ({
+  groups: [],
+  setGroups: (groups) => set({ groups }),
+  clearGroups: () => set({ groups: [] }),
+}))
+
+function liveNodeIdSet(): Set<string> {
+  return new Set(Object.keys(useScene.getState().nodes))
+}
+
+/**
+ * Membership is never rewritten when a member is deleted — every read filters
+ * against the live scene instead. Deleting a member and undoing must restore it
+ * to its group, and a destructive prune would have already dropped it (or the
+ * whole group, once it fell under the two-member floor).
+ */
+export function expandSessionSelectionForNode(nodeId: string): string[] | null {
+  const groups = useSessionGroups.getState().groups
+  if (groups.length === 0) return null
+  return expandSessionGroupMembers(groups, nodeId, liveNodeIdSet())
+}
+
+/** Ctrl/Cmd+G — create session group from multi-selection. */
+export function groupCurrentSelection(): boolean {
+  const selectedIds = useViewer.getState().selection.selectedIds as string[]
+  if (selectedIds.length < 2) return false
+
+  const liveIds = liveNodeIdSet()
+  const { groups, created } = createSessionGroup(useSessionGroups.getState().groups, selectedIds, {
+    liveIds,
+  })
+  useSessionGroups.getState().setGroups(groups)
+  if (!created) return false
+
+  useViewer.getState().setSelection({
+    selectedIds: created.memberIds as AnyNodeId[],
+  })
+  sfxEmitter.emit('sfx:menu-click')
+  return true
+}
+
+/** Ctrl/Cmd+Shift+G — dissolve session groups intersecting selection. */
+export function ungroupCurrentSelection(): boolean {
+  const selectedIds = useViewer.getState().selection.selectedIds as string[]
+  if (selectedIds.length === 0) return false
+
+  const liveIds = liveNodeIdSet()
+  const { groups, dissolved } = ungroupSessionSelection(
+    useSessionGroups.getState().groups,
+    selectedIds,
+    liveIds,
+  )
+  if (dissolved.length === 0) return false
+  useSessionGroups.getState().setGroups(groups)
+  sfxEmitter.emit('sfx:menu-click')
+  return true
+}
+
+export function currentSelectionMatchesSessionGroup(): SessionSelectionGroup | null {
+  return selectionMatchesSessionGroup(
+    useSessionGroups.getState().groups,
+    useViewer.getState().selection.selectedIds as string[],
+    liveNodeIdSet(),
+  )
+}
+
+export function currentSelectionIntersectsSessionGroup(): boolean {
+  return selectionIntersectsSessionGroup(
+    useSessionGroups.getState().groups,
+    useViewer.getState().selection.selectedIds as string[],
+    liveNodeIdSet(),
+  )
+}
+
+export function currentSelectionCanCreateSessionGroup(): boolean {
+  return canCreateSessionGroup(
+    useSessionGroups.getState().groups,
+    useViewer.getState().selection.selectedIds as string[],
+    liveNodeIdSet(),
+  )
+}
+
+export default useSessionGroups