@synchronized-console/shared 2.25.7 → 2.31.14

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

@@ -0,0 +1,353 @@
+import { describe, expect, it } from 'vitest'
+import {
+  createGetParamFromResources,
+  parseResourceFromString,
+  parseUrlParameters,
+  resourceBuilder
+} from './route.js'
+
+describe('Viewer Route Helpers', () => {
+  describe('parseResourceFromString', () => {
+    it('parses "all" as ViewerAllModelsResource', () => {
+      const resource = parseResourceFromString('all')
+      expect(resource.type).toBe('all-models')
+      expect(resource.toString()).toBe('all')
+    })
+
+    it('parses modelId as ViewerModelResource', () => {
+      const resource = parseResourceFromString('abc123')
+      expect(resource.type).toBe('Model')
+      expect(resource.toString()).toBe('abc123')
+    })
+
+    it('parses modelId@versionId as ViewerModelResource', () => {
+      const resource = parseResourceFromString('abc123@ver456')
+      expect(resource.type).toBe('Model')
+      expect(resource.toString()).toBe('abc123@ver456')
+    })
+
+    it('parses $folderName as ViewerModelFolderResource', () => {
+      const resource = parseResourceFromString('$myFolder')
+      expect(resource.type).toBe('ModelFolder')
+      expect(resource.toString()).toBe('$myFolder') // keep casing
+    })
+
+    it('parses 32-char string as ViewerObjectResource', () => {
+      const objectId = '1234567890abcdef1234567890abcdef'
+      const resource = parseResourceFromString(objectId)
+      expect(resource.type).toBe('Object')
+      expect(resource.toString()).toBe(objectId)
+    })
+
+    it('parses modelId with uppercase as ViewerModelResource and lowercases it', () => {
+      const resource = parseResourceFromString('ABC123')
+      expect(resource.type).toBe('Model')
+      expect(resource.toString()).toBe('abc123')
+    })
+
+    it('parses $FOLDERNAME with uppercase as ViewerModelFolderResource and lowercases it', () => {
+      const resource = parseResourceFromString('$FOLDERNAME')
+      expect(resource.type).toBe('ModelFolder')
+      expect(resource.toString()).toBe('$FOLDERNAME')
+    })
+
+    it('parses modelId@versionId with uppercase as ViewerModelResource and lowercases it', () => {
+      const resource = parseResourceFromString('ABC123@VER456')
+      expect(resource.type).toBe('Model')
+      expect(resource.toString()).toBe('abc123@ver456')
+    })
+  })
+
+  describe('parseUrlParameters', () => {
+    it('returns empty array for empty string', () => {
+      expect(parseUrlParameters('')).toEqual([])
+    })
+
+    it('parses single modelId', () => {
+      const resources = parseUrlParameters('abc123')
+      expect(resources).toHaveLength(1)
+      expect(resources[0].type).toBe('Model')
+      expect(resources[0].toString()).toBe('abc123')
+    })
+
+    it('parses multiple modelIds and sorts them', () => {
+      const resources = parseUrlParameters('zxy,abc')
+      expect(resources).toHaveLength(2)
+      expect(resources[0].toString()).toBe('abc')
+      expect(resources[1].toString()).toBe('zxy')
+    })
+
+    it('parses modelId@versionId and $folder', () => {
+      const resources = parseUrlParameters('abc@ver,$folder')
+      expect(resources).toHaveLength(2)
+      expect(resources.some((r) => r.type === 'Model')).toBe(true)
+      expect(resources.some((r) => r.type === 'ModelFolder')).toBe(true)
+    })
+
+    it('removes duplicate resources', () => {
+      const resources = parseUrlParameters('abc,abc,ABC')
+      expect(resources).toHaveLength(1)
+      expect(resources[0].toString()).toBe('abc')
+    })
+
+    it('handles all resource types together', () => {
+      const objectId = '1234567890abcdef1234567890abcdef'
+      const resources = parseUrlParameters(`all,abc@ver,$folder,${objectId}`)
+      expect(resources).toHaveLength(4)
+      expect(resources.some((r) => r.type === 'all-models')).toBe(true)
+      expect(resources.some((r) => r.type === 'Model')).toBe(true)
+      expect(resources.some((r) => r.type === 'ModelFolder')).toBe(true)
+      expect(resources.some((r) => r.type === 'Object')).toBe(true)
+    })
+
+    it('handles whitespace and ignores empty parts', () => {
+      const resources = parseUrlParameters('abc, , ,def')
+      expect(resources).toHaveLength(2)
+      expect(resources[0].toString()).toBe('abc')
+      expect(resources[1].toString()).toBe('def')
+    })
+
+    it('lowercases all resource strings', () => {
+      const resources = parseUrlParameters('ABC,$FOLDER,DEF@VER')
+      expect(resources.map((r) => r.toString()).sort()).toEqual(
+        ['$FOLDER', 'abc', 'def@ver'].sort()
+      )
+    })
+
+    it('sorts resources alphabetically by toString', () => {
+      const resources = parseUrlParameters('z,abc,def')
+      expect(resources.map((r) => r.toString())).toEqual(['abc', 'def', 'z'])
+    })
+  })
+
+  describe('createGetParamFromResources', () => {
+    it('returns empty string for empty resource array', () => {
+      expect(createGetParamFromResources([])).toBe('')
+    })
+
+    it('returns single resource string for one resource', () => {
+      const resources = [parseResourceFromString('abc123')]
+      expect(createGetParamFromResources(resources)).toBe('abc123')
+    })
+
+    it('returns comma-separated, sorted, lowercased resource strings', () => {
+      const resources = [
+        parseResourceFromString('ZXY'),
+        parseResourceFromString('abc'),
+        parseResourceFromString('DEF@VER')
+      ]
+      expect(createGetParamFromResources(resources)).toBe('abc,def@ver,zxy')
+    })
+
+    it('removes duplicate resources (case-insensitive)', () => {
+      const resources = [
+        parseResourceFromString('abc'),
+        parseResourceFromString('ABC'),
+        parseResourceFromString('Abc')
+      ]
+      expect(createGetParamFromResources(resources)).toBe('abc')
+    })
+
+    it('handles all resource types and sorts them', () => {
+      const objectId = '1234567890abcdef1234567890abcdef'
+      const resources = [
+        parseResourceFromString('all'),
+        parseResourceFromString('abc@ver'),
+        parseResourceFromString('$folder'),
+        parseResourceFromString(objectId)
+      ]
+      expect(createGetParamFromResources(resources)).toBe(
+        `$folder,1234567890abcdef1234567890abcdef,abc@ver,all`
+          .split(',')
+          .sort()
+          .join(',')
+      )
+    })
+
+    it('handles resources with mixed case and sorts them', () => {
+      const resources = [
+        parseResourceFromString('DEF@VER'),
+        parseResourceFromString('abc'),
+        parseResourceFromString('ZXY')
+      ]
+      expect(createGetParamFromResources(resources)).toBe('abc,def@ver,zxy')
+    })
+
+    it('handles resources with $ in folder names', () => {
+      const resources = [
+        parseResourceFromString('$FolderA'),
+        parseResourceFromString('$folderb')
+      ]
+      expect(createGetParamFromResources(resources)).toBe('$FolderA,$folderb')
+    })
+  })
+
+  describe('resourceBuilder', () => {
+    it('can add a single model', () => {
+      const builder = resourceBuilder().addModel('abc123')
+      expect(builder.length).toBe(1)
+      expect(builder.toResources()[0].type).toBe('Model')
+      expect(builder.toString()).toBe('abc123')
+    })
+
+    it('can add a model with version', () => {
+      const builder = resourceBuilder().addModel('abc123', 'ver456')
+      expect(builder.length).toBe(1)
+      expect(builder.toResources()[0].toString()).toBe('abc123@ver456')
+    })
+
+    it('can add all models', () => {
+      const builder = resourceBuilder().addAllModels()
+      expect(builder.length).toBe(1)
+      expect(builder.toResources()[0].type).toBe('all-models')
+      expect(builder.toString()).toBe('all')
+    })
+
+    it('can add a model folder', () => {
+      const builder = resourceBuilder().addModelFolder('MyFolder')
+      expect(builder.length).toBe(1)
+      expect(builder.toResources()[0].type).toBe('ModelFolder')
+      expect(builder.toString()).toBe('$MyFolder')
+    })
+
+    it('can add an object', () => {
+      const objectId = '1234567890abcdef1234567890abcdef'
+      const builder = resourceBuilder().addObject(objectId)
+      expect(builder.length).toBe(1)
+      expect(builder.toResources()[0].type).toBe('Object')
+      expect(builder.toString()).toBe(objectId)
+    })
+
+    it('can add from string with multiple resources', () => {
+      const builder = resourceBuilder().addFromString('abc,def@ver,$folder')
+      expect(builder.length).toBe(3)
+      expect(builder.toString().split(',').sort()).toEqual(
+        ['abc', 'def@ver', '$folder'].sort()
+      )
+    })
+
+    it('can clear versionIds', () => {
+      const builder = resourceBuilder().addResources('abc,def@ver')
+      expect(builder.length).toBe(2)
+      expect(builder.toString()).toBe('abc,def@ver')
+
+      builder.clearVersions()
+      expect(builder.length).toBe(2)
+      expect(builder.toString()).toBe('abc,def')
+    })
+
+    it('can add resources array', () => {
+      const resources = [
+        parseResourceFromString('abc'),
+        parseResourceFromString('def@ver')
+      ]
+      const builder = resourceBuilder().addResources(resources)
+      expect(builder.length).toBe(2)
+      expect(builder.toString().split(',').sort()).toEqual(['abc', 'def@ver'].sort())
+    })
+
+    it('can clear resources', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      expect(builder.length).toBe(2)
+      builder.clear()
+      expect(builder.length).toBe(0)
+      expect(builder.toString()).toBe('')
+    })
+
+    it('can clone builder', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      const clone = builder.clone()
+      expect(clone).not.toBe(builder)
+      expect(clone.toString()).toBe(builder.toString())
+      clone.addModel('xyz')
+      expect(clone.length).toBe(3)
+      expect(builder.length).toBe(2)
+    })
+
+    it('can iterate over resources', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      const ids = []
+      for (const r of builder) {
+        ids.push(r.toString())
+      }
+      expect(ids.sort()).toEqual(['abc', 'def'].sort())
+    })
+
+    it('can use forEach', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      const ids: string[] = []
+      builder.forEach((r) => ids.push(r.toString()))
+      expect(ids.sort()).toEqual(['abc', 'def'].sort())
+    })
+
+    it('can use filter', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      const res = builder.filter((r) => r.toString() === 'abc')
+      expect(res.length).toBe(1)
+      expect(res[0].toString()).toBe('abc')
+    })
+
+    it('can use map', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      const types = builder.map((r) => r.type)
+      expect(types.sort()).toEqual(['Model', 'Model'].sort())
+    })
+
+    it('toResources returns a copy', () => {
+      const builder = resourceBuilder().addModel('abc')
+      const arr = builder.toResources()
+      expect(arr).toHaveLength(1)
+      arr.push(parseResourceFromString('def'))
+      expect(builder.length).toBe(1)
+    })
+
+    it('can find an item', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      const found = builder.find((r) => r.toString() === 'def')
+      expect(found).toBeDefined()
+      expect(found?.toString()).toBe('def')
+    })
+
+    it('addNew only adds new resources', () => {
+      const builder = resourceBuilder().addModel('abc').addModel('def')
+      builder.addNew('abc') // should not add
+      expect(builder.length).toBe(2)
+      builder.addNew('abc@yaya') // should not add
+      expect(builder.length).toBe(2)
+      builder.addNew('xyz') // should add
+      expect(builder.length).toBe(3)
+      builder.addNew('$newFolder') // should add
+      expect(builder.length).toBe(4)
+      expect(builder.toString()).toBe('$newFolder,abc,def,xyz') // $newFolder should keep casing
+    })
+
+    it('addResources can add any kind of ViewerResources', () => {
+      const resources = [
+        'abc',
+        ['def@ver', '$folder'],
+        parseResourceFromString('abc2'),
+        parseResourceFromString('def2@ver'),
+        parseResourceFromString('$2folder'),
+        resourceBuilder().addModel('nestedModel')
+      ]
+
+      const builder = resourceBuilder()
+      for (const res of resources) {
+        builder.addResources(res)
+      }
+
+      expect(builder.length).toBe(7)
+      expect(builder.toString().split(',').sort()).toEqual(
+        [
+          'abc',
+          'abc2',
+          'def@ver',
+          'def2@ver',
+          'nestedmodel',
+          '$2folder',
+          '$folder'
+        ].sort()
+      )
+    })
+  })
+})

package/src/viewer/helpers/route.ts

@@ -1,11 +1,13 @@
-import { uniq, uniqBy } from '#lodash'
+import { isString, uniq, uniqBy } from '#lodash'
 
-export enum ViewerResourceType {
-  Model = 'Model',
-  Object = 'Object',
-  ModelFolder = 'ModelFolder',
-  AllModels = 'all-models'
+export const ViewerResourceType = <const>{
+  Model: 'Model',
+  Object: 'Object',
+  ModelFolder: 'ModelFolder',
+  AllModels: 'all-models'
 }
+export type ViewerResourceType =
+  (typeof ViewerResourceType)[keyof typeof ViewerResourceType]
 
 export interface ViewerResource {
   type: ViewerResourceType
@@ -27,8 +29,8 @@ export class ViewerModelResource implements ViewerResource {
 
   constructor(modelId: string, versionId?: string) {
     this.type = ViewerResourceType.Model
-    this.modelId = modelId
-    this.versionId = versionId
+    this.modelId = modelId.toLowerCase()
+    this.versionId = versionId?.toLowerCase()
   }
 
   toString(): string {
@@ -43,7 +45,7 @@ export class ViewerVersionResource extends ViewerModelResource {
 
   constructor(modelId: string, versionId: string) {
     super(modelId, versionId)
-    this.versionId = versionId
+    this.versionId = versionId?.toLowerCase()
   }
 
   toJSON() {
@@ -57,7 +59,7 @@ export class ViewerObjectResource implements ViewerResource {
 
   constructor(objectId: string) {
     this.type = ViewerResourceType.Object
-    this.objectId = objectId
+    this.objectId = objectId.toLowerCase()
   }
 
   toString(): string {
@@ -75,26 +77,36 @@ export class ViewerModelFolderResource implements ViewerResource {
   }
 
   toString(): string {
-    return ('$' + this.folderName).toLowerCase()
+    return '$' + this.folderName
+  }
+}
+
+export const parseResourceFromString = (resourceId: string): ViewerResource => {
+  if (resourceId === 'all') {
+    return new ViewerAllModelsResource()
+  } else if (resourceId.includes('@')) {
+    const [modelId, versionId] = resourceId.split('@')
+    return new ViewerVersionResource(modelId, versionId)
+  } else if (resourceId.startsWith('$')) {
+    return new ViewerModelFolderResource(resourceId.substring(1))
+  } else if (resourceId.length === 32) {
+    return new ViewerObjectResource(resourceId)
+  } else {
+    return new ViewerModelResource(resourceId)
   }
 }
 
 export function parseUrlParameters(resourceGetParam: string) {
   if (!resourceGetParam?.length) return []
-  const parts = resourceGetParam.toLowerCase().split(',').sort()
+  const parts = resourceGetParam
+    .split(',')
+    .filter((i) => i.trim().length)
+    .sort()
   const resources: ViewerResource[] = []
   for (const part of parts) {
-    if (part === 'all') {
-      resources.push(new ViewerAllModelsResource())
-    } else if (part.includes('@')) {
-      const [modelId, versionId] = part.split('@')
-      resources.push(new ViewerModelResource(modelId, versionId))
-    } else if (part.startsWith('$')) {
-      resources.push(new ViewerModelFolderResource(part.substring(1)))
-    } else if (part.length === 32) {
-      resources.push(new ViewerObjectResource(part))
-    } else {
-      resources.push(new ViewerModelResource(part))
+    const resource = parseResourceFromString(part)
+    if (resource) {
+      resources.push(resource)
     }
   }
 
@@ -103,7 +115,7 @@ export function parseUrlParameters(resourceGetParam: string) {
 }
 
 export function createGetParamFromResources(resources: ViewerResource[]) {
-  const resourceParts = uniq(resources.map((r) => r.toString().toLowerCase())).sort()
+  const resourceParts = uniq(resources.map((r) => r.toString())).sort()
   return resourceParts.join(',')
 }
 
@@ -120,35 +132,176 @@ export const isModelFolderResource = (
   r: ViewerResource
 ): r is ViewerModelFolderResource => r.type === ViewerResourceType.ModelFolder
 
-class ViewerResourceBuilder {
+type StringViewerResourcesTarget = string | string[]
+export type ViewerResourcesTarget =
+  | ViewerResourceBuilder
+  | ViewerResource[]
+  | ViewerResource
+  | StringViewerResourcesTarget
+
+const toViewerResourceArray = (res: ViewerResourcesTarget): ViewerResource[] => {
+  if (res instanceof ViewerResourceBuilder) {
+    return res.toResources()
+  }
+
+  const fixString = (r: string | ViewerResource): ViewerResource[] =>
+    isString(r) ? parseUrlParameters(r) : [r]
+
+  if (Array.isArray(res)) {
+    return res.flatMap(fixString)
+  } else {
+    return fixString(res)
+  }
+}
+
+class ViewerResourceBuilder implements Iterable<ViewerResource> {
   #resources: ViewerResource[] = []
 
+  #order() {
+    this.#resources = uniq(this.#resources).sort()
+  }
+
   addAllModels() {
     this.#resources.push(new ViewerAllModelsResource())
+    this.#order()
     return this
   }
   addModel(modelId: string, versionId?: string) {
     this.#resources.push(new ViewerModelResource(modelId, versionId))
+    this.#order()
     return this
   }
   addModelFolder(folderName: string) {
     this.#resources.push(new ViewerModelFolderResource(folderName))
+    this.#order()
     return this
   }
   addObject(objectId: string) {
     this.#resources.push(new ViewerObjectResource(objectId))
+    this.#order()
     return this
   }
+  /**
+   * @deprecated Use 'addResources' or 'addNew' instead
+   */
+  addFromString(stringResources: StringViewerResourcesTarget) {
+    const strings = Array.isArray(stringResources) ? stringResources : [stringResources]
+    for (const resourceIdString of strings) {
+      const resources = parseUrlParameters(resourceIdString.toLowerCase())
+      this.#resources.push(...resources)
+    }
+
+    this.#order()
+    return this
+  }
+  addResources(res: ViewerResourcesTarget) {
+    this.#resources.push(...toViewerResourceArray(res))
+    this.#order()
+    return this
+  }
+
+  /**
+   * Only add those resources that are not already in the builder.
+   */
+  addNew(
+    incoming: ViewerResourcesTarget,
+    options?: {
+      /**
+       * If true, will require exact version matches for model resources
+       * Default: false
+       */
+      requireExactMatch?: boolean
+    }
+  ) {
+    const { requireExactMatch = false } = options || {}
+    const resources = toViewerResourceArray(incoming)
+
+    const newResources: ViewerResource[] = this.#resources.slice()
+    for (const resource of resources) {
+      // check if newResources has a resource w/ same modelId (check w/ isModelResource)
+      if (isModelResource(resource) && !requireExactMatch) {
+        const existing = newResources.find(
+          (r) => isModelResource(r) && r.modelId === resource.modelId
+        )
+        if (!existing) {
+          newResources.push(resource)
+        }
+      } else if (!newResources.some((r) => r.toString() === resource.toString())) {
+        newResources.push(resource)
+      }
+    }
+
+    this.#resources = newResources
+    this.#order()
+
+    return this
+  }
+
   toString() {
     return createGetParamFromResources(this.#resources)
   }
   toResources() {
     return this.#resources.slice()
   }
+  toResourceIds() {
+    return this.toResources().map((r) => r.toString())
+  }
   clear() {
     this.#resources = []
     return this
   }
+  clone() {
+    const clone = new ViewerResourceBuilder()
+    const resources = this.toString()
+    clone.addResources(resources)
+    return clone
+  }
+  get length() {
+    return this.#resources.length
+  }
+
+  /**
+   * Remove specified versionIds from any model resources
+   */
+  clearVersions() {
+    this.#resources.forEach((r) => {
+      if (!isModelResource(r)) return
+      r.versionId = undefined
+    })
+    return this
+  }
+
+  isEqualTo(resource: ViewerResourcesTarget) {
+    const incomingBuilder = resourceBuilder().addResources(resource)
+    return this.toString() === incomingBuilder.toString()
+  }
+
+  forEach(callback: (resource: ViewerResource) => void) {
+    this.#resources.forEach(callback)
+    return this
+  }
+
+  filter<Res extends ViewerResource>(
+    callback: (resource: ViewerResource) => resource is Res
+  ): Res[]
+  filter(callback: (resource: ViewerResource) => boolean): ViewerResource[]
+  filter(callback: (resource: ViewerResource) => boolean) {
+    return this.#resources.filter(callback)
+  }
+
+  find<Res extends ViewerResource>(
+    callback: (resource: ViewerResource) => resource is Res
+  ): Res | undefined
+  find(callback: (resource: ViewerResource) => boolean): ViewerResource | undefined
+  find(callback: (resource: ViewerResource) => boolean) {
+    return this.#resources.find(callback)
+  }
+  map<T>(callback: (resource: ViewerResource) => T): T[] {
+    return this.#resources.map(callback)
+  }
+  [Symbol.iterator](): Iterator<ViewerResource> {
+    return this.#resources[Symbol.iterator]()
+  }
 }
 
 /**
@@ -157,3 +310,5 @@ class ViewerResourceBuilder {
 export function resourceBuilder() {
   return new ViewerResourceBuilder()
 }
+
+export type ResourceBuilder = ReturnType<typeof resourceBuilder>