@synchronized-console/shared 2.25.7 → 2.31.14

package/src/viewer/helpers/state.spec.ts

@@ -0,0 +1,252 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { describe, it, expect } from 'vitest'
+import {
+  formatSerializedViewerState,
+  inputToVersionedState,
+  isSerializedViewerState,
+  isVersionedSerializedViewerState,
+  SERIALIZED_VIEWER_STATE_VERSION,
+  SerializedViewerState,
+  VersionedSerializedViewerState
+} from './state.js'
+import { UnformattableSerializedViewerStateError } from '../errors/index.js'
+
+describe('Viewer State helpers', () => {
+  describe('isSerializedViewerState', () => {
+    it('returns true for valid SerializedViewerState', () => {
+      const valid: SerializedViewerState = {
+        projectId: 'pid',
+        sessionId: 'sid',
+        viewer: { metadata: { filteringState: null } },
+        resources: {
+          request: {
+            resourceIdString: 'rid',
+            threadFilters: {}
+          }
+        },
+        ui: {
+          threads: {
+            openThread: { threadId: null, isTyping: false, newThreadEditor: false }
+          },
+          diff: { command: null, time: 0, mode: 1 },
+          spotlightUserSessionId: null,
+          filters: {
+            isolatedObjectIds: [],
+            hiddenObjectIds: [],
+            selectedObjectApplicationIds: {},
+            propertyFilters: [],
+            activeColorFilterId: null,
+            filterLogic: 'all'
+          },
+          camera: {
+            position: [0, 0, 0],
+            target: [0, 0, 0],
+            isOrthoProjection: false,
+            zoom: 1
+          },
+          viewMode: {
+            mode: 0,
+            edgesColor: 0,
+            edgesEnabled: true,
+            outlineOpacity: 0,
+            edgesWeight: 0
+          },
+          sectionBox: null,
+          lightConfig: {},
+          explodeFactor: 0,
+          selection: null,
+          measurement: { enabled: false, options: null, measurements: [] }
+        }
+      }
+      expect(isSerializedViewerState(valid)).toBe(true)
+    })
+
+    it('returns false for missing keys', () => {
+      expect(isSerializedViewerState({})).toBe(false)
+      expect(isSerializedViewerState(null)).toBe(false)
+      expect(isSerializedViewerState(undefined)).toBe(false)
+      expect(isSerializedViewerState({ projectId: 'pid' })).toBe(false)
+    })
+
+    it('returns false for non-object values', () => {
+      expect(isSerializedViewerState(123)).toBe(false)
+      expect(isSerializedViewerState('string')).toBe(false)
+      expect(isSerializedViewerState([])).toBe(false)
+    })
+  })
+
+  describe('formatSerializedViewerState', () => {
+    it('fills missing optional fields with defaults', () => {
+      const partial = {
+        projectId: 'pid',
+        viewer: { metadata: {} },
+        resources: { request: { resourceIdString: 'rid' } },
+        ui: {
+          camera: { position: [1, 2, 3], target: [4, 5, 6] }
+        }
+      }
+      const formatted = formatSerializedViewerState(partial as any)
+      expect(formatted.projectId).toBe('pid')
+      expect(formatted.sessionId).toMatch(/nullSessionId-/)
+      expect(formatted.ui.camera.position).toEqual([1, 2, 3])
+      expect(formatted.ui.camera.target).toEqual([4, 5, 6])
+      expect(formatted.ui.measurement.options?.units).toBe('m')
+      expect(formatted.ui.filters.selectedObjectApplicationIds).toEqual({})
+    })
+
+    it('throws UnformattableSerializedViewerStateError for missing required fields', () => {
+      expect(() => formatSerializedViewerState({} as any)).toThrow(
+        UnformattableSerializedViewerStateError
+      )
+      expect(() =>
+        formatSerializedViewerState({
+          projectId: 'pid',
+          viewer: { metadata: {} },
+          resources: { request: { resourceIdString: 'rid' } },
+          ui: { camera: { target: [1, 2, 3] } }
+        } as any)
+      ).toThrow(UnformattableSerializedViewerStateError)
+    })
+
+    it('handles legacy selectedObjectIds', () => {
+      const partial = {
+        projectId: 'pid',
+        viewer: { metadata: {} },
+        resources: { request: { resourceIdString: 'rid' } },
+        ui: {
+          camera: { position: [1, 2, 3], target: [4, 5, 6] },
+          filters: { selectedObjectIds: ['a', 'b'] }
+        }
+      }
+      const formatted = formatSerializedViewerState(partial as any)
+      expect(formatted.ui.filters.selectedObjectApplicationIds).toEqual({
+        a: null,
+        b: null
+      })
+    })
+  })
+
+  describe('inputToVersionedState', () => {
+    it('returns versioned state for valid input', () => {
+      const valid: SerializedViewerState = {
+        projectId: 'pid',
+        sessionId: 'sid',
+        viewer: { metadata: { filteringState: null } },
+        resources: {
+          request: {
+            resourceIdString: 'rid',
+            threadFilters: {}
+          }
+        },
+        ui: {
+          threads: {
+            openThread: { threadId: null, isTyping: false, newThreadEditor: false }
+          },
+          diff: { command: null, time: 0, mode: 1 },
+          spotlightUserSessionId: null,
+          filters: {
+            isolatedObjectIds: [],
+            hiddenObjectIds: [],
+            selectedObjectApplicationIds: {},
+            propertyFilters: [],
+            activeColorFilterId: null,
+            filterLogic: 'all'
+          },
+          camera: {
+            position: [0, 0, 0],
+            target: [0, 0, 0],
+            isOrthoProjection: false,
+            zoom: 1
+          },
+          viewMode: {
+            mode: 0,
+            edgesColor: 0,
+            edgesEnabled: true,
+            outlineOpacity: 0,
+            edgesWeight: 0
+          },
+          sectionBox: null,
+          lightConfig: {},
+          explodeFactor: 0,
+          selection: null,
+          measurement: { enabled: false, options: null, measurements: [] }
+        }
+      }
+      const result = inputToVersionedState(valid)
+      expect(result).not.toBeNull()
+      expect(result?.version).toBe(SERIALIZED_VIEWER_STATE_VERSION)
+      expect(result?.state.projectId).toBe('pid')
+    })
+
+    it('returns null for invalid input', () => {
+      expect(inputToVersionedState(null)).toBeNull()
+      expect(inputToVersionedState({})).toBeNull()
+      expect(inputToVersionedState(123)).toBeNull()
+    })
+  })
+
+  describe('isVersionedSerializedViewerState', () => {
+    it('returns true for valid VersionedSerializedViewerState', () => {
+      const valid: VersionedSerializedViewerState = {
+        version: SERIALIZED_VIEWER_STATE_VERSION,
+        state: {
+          projectId: 'pid',
+          sessionId: 'sid',
+          viewer: { metadata: { filteringState: null } },
+          resources: {
+            request: {
+              resourceIdString: 'rid',
+              threadFilters: {}
+            }
+          },
+          ui: {
+            threads: {
+              openThread: { threadId: null, isTyping: false, newThreadEditor: false }
+            },
+            diff: { command: null, time: 0, mode: 1 },
+            spotlightUserSessionId: null,
+            filters: {
+              isolatedObjectIds: [],
+              hiddenObjectIds: [],
+              selectedObjectApplicationIds: {},
+              propertyFilters: [],
+              activeColorFilterId: null,
+              filterLogic: 'all'
+            },
+            camera: {
+              position: [0, 0, 0],
+              target: [0, 0, 0],
+              isOrthoProjection: false,
+              zoom: 1
+            },
+            viewMode: {
+              mode: 0,
+              edgesColor: 0,
+              edgesEnabled: true,
+              outlineOpacity: 0,
+              edgesWeight: 0
+            },
+            sectionBox: null,
+            lightConfig: {},
+            explodeFactor: 0,
+            selection: null,
+            measurement: { enabled: false, options: null, measurements: [] }
+          }
+        }
+      }
+      expect(isVersionedSerializedViewerState(valid)).toBe(true)
+    })
+
+    it('returns false for missing version or state', () => {
+      expect(isVersionedSerializedViewerState({})).toBe(false)
+      expect(isVersionedSerializedViewerState({ version: 1 })).toBe(false)
+      expect(isVersionedSerializedViewerState({ state: {} })).toBe(false)
+      expect(isVersionedSerializedViewerState(null)).toBe(false)
+    })
+
+    it('returns false for invalid state', () => {
+      expect(isVersionedSerializedViewerState({ version: 1, state: {} })).toBe(false)
+    })
+  })
+})

package/src/viewer/helpers/state.ts

@@ -1,18 +1,20 @@
-import { intersection, isObjectLike } from '#lodash'
+import { has, intersection, isNumber, isObjectLike } from '#lodash'
 import type { MaybeNullOrUndefined, Nullable } from '../../core/helpers/utilityTypes.js'
 import type { PartialDeep } from 'type-fest'
 import { UnformattableSerializedViewerStateError } from '../errors/index.js'
 import { coerceUndefinedValuesToNull } from '../../core/index.js'
 
+export const defaultViewModeEdgeColorValue = 'DEFAULT_EDGE_COLOR'
+
 /** Redefining these is unfortunate. Especially since they are not part of viewer-core */
-enum MeasurementType {
+export enum MeasurementType {
   PERPENDICULAR = 0,
   POINTTOPOINT = 1,
   AREA = 2,
   POINT = 3
 }
 
-interface MeasurementOptions {
+export interface MeasurementOptions {
   visible: boolean
   type?: MeasurementType
   vertexSnap?: boolean
@@ -21,6 +23,27 @@ interface MeasurementOptions {
   chain?: boolean
 }
 
+export interface MeasurementData {
+  type: MeasurementType
+  startPoint: readonly [number, number, number] // vec3
+  endPoint: readonly [number, number, number] // vec3
+  startNormal: readonly [number, number, number] // vec3
+  endNormal: readonly [number, number, number] // vec3
+  value: number
+  innerPoints?: (readonly [number, number, number])[] // array of vec3
+  units?: string
+  precision?: number
+  uuid: string
+}
+
+export const defaultMeasurementOptions: Readonly<MeasurementOptions> = Object.freeze({
+  visible: true,
+  type: MeasurementType.POINTTOPOINT,
+  vertexSnap: false,
+  units: 'm',
+  precision: 2
+})
+
 export interface SectionBoxData {
   min: number[]
   max: number[]
@@ -35,8 +58,21 @@ export interface SectionBoxData {
  * - ui.diff added
  * v1.2 -> v1.3
  * - ui.filters.selectedObjectIds removed in favor of ui.filters.selectedObjectApplicationIds
+ * v1.3 -> 1.4
+ * - ui.viewMode -> ui.viewMode.mode
+ * - ui.viewMode has new keys: edgesEnabled, edgesWeight, outlineOpacity, edgesColor
+ * v1.4 -> 1.5
+ * - ui.measurement.measurements added
+ * v1.5 -> 1.6
+ * - ui.filters.propertyFilter -> propertyFilters
+ * - activeColorFilterId added
+ * v1.6 -> 1.7
+ * - ui.filters.filterLogic added
+ * - ui.filters.propertyFilters.condition updated
+ * v1.7 -> 1.8
+ * - ui.filters.propertyFilters.numericRange added
  */
-export const SERIALIZED_VIEWER_STATE_VERSION = 1.3
+export const SERIALIZED_VIEWER_STATE_VERSION = 1.8
 
 export type SerializedViewerState = {
   projectId: string
@@ -77,10 +113,16 @@ export type SerializedViewerState = {
       hiddenObjectIds: string[]
       /** Map of object id => application id or null, if no application id */
       selectedObjectApplicationIds: Record<string, string | null>
-      propertyFilter: {
+      propertyFilters: Array<{
         key: Nullable<string>
         isApplied: boolean
-      }
+        selectedValues: string[]
+        id: string
+        condition: string
+        numericRange?: { min: number; max: number }
+      }>
+      activeColorFilterId: Nullable<string>
+      filterLogic: string
     }
     camera: {
       position: number[]
@@ -88,7 +130,13 @@ export type SerializedViewerState = {
       isOrthoProjection: boolean
       zoom: number
     }
-    viewMode: number
+    viewMode: {
+      mode: number
+      edgesEnabled: boolean
+      edgesWeight: number
+      outlineOpacity: number
+      edgesColor: typeof defaultViewModeEdgeColorValue | number
+    }
     sectionBox: Nullable<SectionBoxData>
     lightConfig: {
       intensity?: number
@@ -101,16 +149,27 @@ export type SerializedViewerState = {
     measurement: {
       enabled: boolean
       options: Nullable<MeasurementOptions>
+      measurements: Array<MeasurementData>
     }
   }
 }
 
+export type VersionedSerializedViewerState = {
+  version: number
+  state: SerializedViewerState
+}
+
 type UnformattedState = PartialDeep<
   SerializedViewerState & {
     // Properties removed from earlier viewer state versions
     ui: {
       filters: {
         selectedObjectIds: string[]
+        // Legacy single propertyFilter for migration
+        propertyFilter: {
+          key: Nullable<string>
+          isApplied: boolean
+        }
       }
     }
   }
@@ -144,14 +203,6 @@ const initializeMissingData = (state: UnformattedState): SerializedViewerState =
     )
   }
 
-  const defaultMeasurementOptions: MeasurementOptions = {
-    visible: false,
-    type: MeasurementType.POINTTOPOINT,
-    vertexSnap: false,
-    units: 'm',
-    precision: 2
-  }
-
   const measurementOptions = {
     ...defaultMeasurementOptions,
     ...state.ui?.measurement?.options
@@ -169,6 +220,12 @@ const initializeMissingData = (state: UnformattedState): SerializedViewerState =
     )
   }
 
+  const viewModeType = isNumber(state.ui?.viewMode)
+    ? state.ui.viewMode
+    : state.ui?.viewMode?.mode
+
+  const viewModeSettings = isNumber(state.ui?.viewMode) ? {} : state.ui?.viewMode
+
   return {
     projectId: state.projectId || throwInvalidError('projectId'),
     sessionId: state.sessionId || `nullSessionId-${Math.random() * 1000}`,
@@ -213,17 +270,61 @@ const initializeMissingData = (state: UnformattedState): SerializedViewerState =
         mode: state.ui?.diff?.mode || 1
       },
       spotlightUserSessionId: state.ui?.spotlightUserSessionId || null,
-      filters: {
-        ...(state.ui?.filters || {}),
-        isolatedObjectIds: state.ui?.filters?.isolatedObjectIds || [],
-        hiddenObjectIds: state.ui?.filters?.hiddenObjectIds || [],
-        selectedObjectApplicationIds,
-        propertyFilter: {
-          ...(state.ui?.filters?.propertyFilter || {}),
-          key: state.ui?.filters?.propertyFilter?.key || null,
-          isApplied: state.ui?.filters?.propertyFilter?.isApplied || false
+      filters: (() => {
+        const baseFilters = {
+          ...(state.ui?.filters || {}),
+          isolatedObjectIds: state.ui?.filters?.isolatedObjectIds || [],
+          hiddenObjectIds: state.ui?.filters?.hiddenObjectIds || [],
+          selectedObjectApplicationIds,
+          activeColorFilterId: state.ui?.filters?.activeColorFilterId || null
         }
-      },
+
+        // Migration logic: handle legacy propertyFilter and new propertyFilters
+        let propertyFilters: Array<{
+          key: Nullable<string>
+          isApplied: boolean
+          selectedValues: string[]
+          id: string
+          condition: string
+          numericRange?: { min: number; max: number }
+        }> = []
+
+        // If new propertyFilters exist and are not empty, use them
+        if (
+          state.ui?.filters?.propertyFilters &&
+          Array.isArray(state.ui.filters.propertyFilters) &&
+          state.ui.filters.propertyFilters.length > 0
+        ) {
+          // Map legacy condition values to new format
+          propertyFilters = state.ui.filters.propertyFilters.map((filter) => ({
+            ...filter,
+            condition:
+              filter.condition === 'AND'
+                ? 'is'
+                : filter.condition === 'OR'
+                ? 'is'
+                : filter.condition
+          }))
+        }
+        // If legacy propertyFilter exists but no propertyFilters (or empty propertyFilters), migrate it
+        else if (state.ui?.filters?.propertyFilter?.key) {
+          propertyFilters = [
+            {
+              key: state.ui.filters.propertyFilter.key,
+              isApplied: state.ui.filters.propertyFilter.isApplied || false,
+              selectedValues: [], // Legacy didn't have selectedValues
+              id: 'legacy-filter', // Generate a consistent ID for legacy filter
+              condition: 'is'
+            }
+          ]
+        }
+
+        return {
+          ...baseFilters,
+          propertyFilters,
+          filterLogic: state.ui?.filters?.filterLogic || 'all'
+        }
+      })(),
       camera: {
         ...(state.ui?.camera || {}),
         position: state.ui?.camera?.position || throwInvalidError('ui.camera.position'),
@@ -231,7 +332,13 @@ const initializeMissingData = (state: UnformattedState): SerializedViewerState =
         isOrthoProjection: state.ui?.camera?.isOrthoProjection || false,
         zoom: state.ui?.camera?.zoom || 1
       },
-      viewMode: state.ui?.viewMode || 0,
+      viewMode: {
+        mode: viewModeType ?? 0,
+        edgesEnabled: viewModeSettings?.edgesEnabled ?? true,
+        edgesWeight: viewModeSettings?.edgesWeight ?? 1,
+        outlineOpacity: viewModeSettings?.outlineOpacity ?? 0.75,
+        edgesColor: viewModeSettings?.edgesColor ?? defaultViewModeEdgeColorValue
+      },
       sectionBox:
         state.ui?.sectionBox?.min?.length && state.ui?.sectionBox.max?.length
           ? // Complains otherwise
@@ -248,7 +355,8 @@ const initializeMissingData = (state: UnformattedState): SerializedViewerState =
       selection: state.ui?.selection || null,
       measurement: {
         enabled: state.ui?.measurement?.enabled ?? false,
-        options: measurementOptions
+        options: measurementOptions,
+        measurements: state.ui?.measurement?.measurements || []
       }
     }
   }
@@ -264,3 +372,26 @@ export const formatSerializedViewerState = (
   const finalState = initializeMissingData(state)
   return finalState
 }
+
+export const inputToVersionedState = (
+  inputSerializedViewerState: unknown
+): Nullable<VersionedSerializedViewerState> => {
+  const state = isSerializedViewerState(inputSerializedViewerState)
+    ? formatSerializedViewerState(inputSerializedViewerState)
+    : null
+  if (!state) return null
+
+  return {
+    version: SERIALIZED_VIEWER_STATE_VERSION,
+    state
+  }
+}
+
+export const isVersionedSerializedViewerState = (
+  data: unknown
+): data is VersionedSerializedViewerState => {
+  if (!data || !isObjectLike(data)) return false
+  if (!has(data, 'version')) return false
+  const stateRaw = (data as Record<string, unknown>).state
+  return isSerializedViewerState(stateRaw)
+}

package/src/workers/fileimport/job.ts

@@ -1,35 +1,49 @@
 import z from 'zod'
 import { TIME } from '../../core/index.js'
 
-const job = z.object({
-  jobId: z.string()
+export const jobPayloadV1 = z.object({
+  serverUrl: z.string().url().describe('The url of the server'),
+  projectId: z.string(),
+  modelId: z.string(),
+  token: z.string(),
+  blobId: z.string(),
+  fileType: z.string(),
+  fileName: z.string(),
+  timeOutSeconds: z
+    .number()
+    .int()
+    .default(30 * TIME.minute)
+    .describe('The timeout for a single attempt of the job, in seconds.')
 })
 
-export const jobPayload = job.merge(
-  z.object({
-    serverUrl: z.string().url().describe('The url of the server'),
-    projectId: z.string(),
-    modelId: z.string(),
-    token: z.string(),
-    blobId: z.string(),
-    fileType: z.string(),
-    fileName: z.string(),
-    timeOutSeconds: z
-      .number()
-      .int()
-      .default(20 * TIME.minute)
-  })
-)
-export type JobPayload = z.infer<typeof jobPayload>
+export type JobPayloadV1 = z.infer<typeof jobPayloadV1>
 
 const baseFileImportResult = z.object({
-  durationSeconds: z.number().describe('Duration to import the file, in seconds')
+  durationSeconds: z
+    .number()
+    .describe('Total duration to download & import the file, in seconds'),
+  downloadDurationSeconds: z
+    .number()
+    .describe(
+      'Duration to download the file, in seconds. This is a sub-component of the total duration.'
+    ),
+  parseDurationSeconds: z
+    .number()
+    .describe(
+      'Duration to parse the file, in seconds. This is a sub-component of the total duration.'
+    ),
+  parser: z.string().describe('The parser used for the import')
 })
 
+export const JobResultStatus = {
+  Error: 'error',
+  Success: 'success'
+} as const
+
 export type FileImportResult = z.infer<typeof baseFileImportResult>
 
 const fileImportSuccessPayload = z.object({
-  status: z.literal('success'),
+  status: z.literal(JobResultStatus.Success),
   warnings: z.array(z.string()), //ok to be empty
   result: baseFileImportResult.merge(z.object({ versionId: z.string() }))
 })
@@ -37,7 +51,7 @@ const fileImportSuccessPayload = z.object({
 export type FileImportSuccessPayload = z.infer<typeof fileImportSuccessPayload>
 
 const fileImportErrorPayload = z.object({
-  status: z.literal('error'),
+  status: z.literal(JobResultStatus.Error),
   reason: z.string(),
   result: baseFileImportResult
 })
@@ -50,3 +64,8 @@ export const fileImportResultPayload = z.discriminatedUnion('status', [
 ])
 
 export type FileImportResultPayload = z.infer<typeof fileImportResultPayload>
+
+export type FileImportJobPayloadV1 = JobPayloadV1 & {
+  jobType: 'fileImport'
+  payloadVersion: 1
+}

package/src/workers/previews/job.ts

@@ -1,7 +1,29 @@
 import z from 'zod'
 
+const JobIdSeparator = '.'
+
+export const jobIdSchema = z
+  .string()
+  .refine((data) => data.split(JobIdSeparator).length === 2, {
+    message: 'jobId must be in the format "projectId.objectId"'
+  })
+
+export const toJobId = (params: { projectId: string; objectId: string }): string => {
+  return `${params.projectId}${JobIdSeparator}${params.objectId}`
+}
+export const fromJobId = (jobId: string): { projectId: string; objectId: string } => {
+  return jobIdSchema
+    .transform((data) => {
+      return {
+        projectId: data.split(JobIdSeparator)[0],
+        objectId: data.split(JobIdSeparator)[1]
+      }
+    })
+    .parse(jobId)
+}
+
 const job = z.object({
-  jobId: z.string()
+  jobId: jobIdSchema
 })
 
 export const jobPayload = job.merge(