adapt-authoring-adaptframework 1.11.0 → 1.12.1

package/lib/AdaptFrameworkUtils.js

@@ -73,7 +73,8 @@ class AdaptFrameworkUtils {
    * @return {String}
    */
   static inferBuildAction (req) {
-    return req.url.slice(1, req.url.indexOf('/', 1))
+    const end = req.url.indexOf('/', 1)
+    return req.url.slice(1, end === -1 ? undefined : end)
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-adaptframework",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "description": "Adapt framework integration for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-adaptframework",
   "license": "GPL-3.0",

package/tests/AdaptFrameworkBuild.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, before, after } from 'node:test'
 import assert from 'node:assert/strict'
+import _ from 'lodash'
 import fs from 'fs/promises'
 import path from 'path'
 import { fileURLToPath } from 'url'
@@ -7,6 +8,38 @@ import AdaptFrameworkBuild from '../lib/AdaptFrameworkBuild.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
+/**
+ * transformContentItems is async and calls App.instance.waitForModule('tags')
+ * at the end. We extract the synchronous logic here to test it in isolation.
+ */
+function transformContentItemsSync (build, items) {
+  items.forEach(i => {
+    ['_courseId', '_parentId'].forEach(k => {
+      i[k] = build.idMap[i[k]] || i[k]
+    })
+    if (i._friendlyId) {
+      i._id = i._friendlyId
+    }
+    const idMapEntries = Object.entries(build.assetData.idMap)
+    const itemString = idMapEntries.reduce((s, [_id, assetPath]) => {
+      const relPath = assetPath.replace(build.courseDir, 'course')
+      return s.replace(new RegExp(_id, 'g'), relPath)
+    }, JSON.stringify(i))
+    Object.assign(i, JSON.parse(itemString))
+    if (i._component) {
+      i._component = build.enabledPlugins.find(p => p.name === i._component)?.targetAttribute.slice(1) ?? i._component
+    }
+  })
+  build.enabledPlugins.forEach(({ targetAttribute, type }) => {
+    let key = `_${type}`
+    if (type === 'component' || type === 'extension') key += 's'
+    const globals = build.courseData.course.data._globals
+    if (!globals?.[targetAttribute]) return
+    _.merge(globals, { [key]: { [targetAttribute]: globals[targetAttribute] } })
+    delete globals[targetAttribute]
+  })
+}
+
 describe('AdaptFrameworkBuild', () => {
   describe('constructor', () => {
     it('should set action and related boolean flags for preview', () => {
@@ -198,5 +231,220 @@ describe('AdaptFrameworkBuild', () => {
       assert.equal(build.courseData.contentObject.data.length, 1)
       assert.equal(build.courseData.contentObject.data[0]._id, 'menu1')
     })
+
+    it('should sort deeply nested content in global order', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: undefined },
+        config: { dir: '/tmp', fileName: 'config.json', data: undefined },
+        contentObject: { dir: '/tmp', fileName: 'contentObjects.json', data: [] },
+        article: { dir: '/tmp', fileName: 'articles.json', data: [] },
+        block: { dir: '/tmp', fileName: 'blocks.json', data: [] },
+        component: { dir: '/tmp', fileName: 'components.json', data: [] }
+      }
+      const items = [
+        { _id: 'course1', _type: 'course' },
+        { _id: 'page1', _type: 'page', _parentId: 'course1', _sortOrder: 1 },
+        { _id: 'page2', _type: 'page', _parentId: 'course1', _sortOrder: 2 },
+        { _id: 'art1', _type: 'article', _parentId: 'page1', _sortOrder: 1 },
+        { _id: 'art2', _type: 'article', _parentId: 'page2', _sortOrder: 1 },
+        { _id: 'art3', _type: 'article', _parentId: 'page1', _sortOrder: 2 }
+      ]
+      build.sortContentItems(items)
+
+      const articleIds = build.courseData.article.data.map(a => a._id)
+      assert.equal(articleIds[0], 'art1')
+      assert.equal(articleIds[1], 'art3')
+      assert.equal(articleIds[2], 'art2')
+    })
+  })
+
+  describe('#transformContentItems()', () => {
+    it('should replace _courseId and _parentId with friendlyIds from idMap', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = { course1: 'co-friendly', page1: 'page-friendly' }
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [
+        { _courseId: 'course1', _parentId: 'page1' }
+      ]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._courseId, 'co-friendly')
+      assert.equal(items[0]._parentId, 'page-friendly')
+    })
+
+    it('should replace _id with _friendlyId when present', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _id: 'abc', _friendlyId: 'my-friendly' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._id, 'my-friendly')
+    })
+
+    it('should not replace _id when _friendlyId is absent', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _id: 'abc' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._id, 'abc')
+    })
+
+    it('should replace asset _ids with relative paths', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.courseDir = '/build/course'
+      build.assetData = { idMap: { asset123: '/build/course/assets/image.png' } }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ graphic: 'asset123' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0].graphic, 'course/assets/image.png')
+    })
+
+    it('should resolve _component to targetAttribute', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = [
+        { name: 'adapt-contrib-text', targetAttribute: '_text', type: 'component' }
+      ]
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _component: 'adapt-contrib-text' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._component, 'text')
+    })
+
+    it('should keep _component as-is when plugin not found', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _component: 'unknown-plugin' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._component, 'unknown-plugin')
+    })
+
+    it('should move globals into nested _extensions object', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = [
+        { name: 'adapt-contrib-trickle', targetAttribute: '_trickle', type: 'extension' }
+      ]
+      build.courseData = {
+        course: {
+          dir: '/tmp',
+          data: {
+            _globals: {
+              _trickle: { label: 'Trickle' }
+            }
+          }
+        }
+      }
+
+      transformContentItemsSync(build, [])
+      const globals = build.courseData.course.data._globals
+      assert.equal(globals._extensions._trickle.label, 'Trickle')
+      assert.equal(globals._trickle, undefined)
+    })
+
+    it('should use _components key for component type globals', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = [
+        { name: 'adapt-contrib-text', targetAttribute: '_text', type: 'component' }
+      ]
+      build.courseData = {
+        course: {
+          dir: '/tmp',
+          data: {
+            _globals: {
+              _text: { ariaRegion: 'Text' }
+            }
+          }
+        }
+      }
+
+      transformContentItemsSync(build, [])
+      const globals = build.courseData.course.data._globals
+      assert.equal(globals._components._text.ariaRegion, 'Text')
+    })
+
+    it('should keep _courseId as-is when not in idMap', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _courseId: 'unmapped' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._courseId, 'unmapped')
+    })
+  })
+
+  describe('#writeContentJson() asset mapping', () => {
+    it('should map asset data to export format for export builds', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      build.assetData = {
+        data: [
+          { title: 'Logo', description: 'A logo', path: 'assets/logo.png', tags: ['branding'], _id: '123', url: '' },
+          { title: 'Icon', description: 'An icon', path: 'assets/icon.svg', tags: [], _id: '456', url: '' }
+        ]
+      }
+      /* simulate the mapping logic from writeContentJson */
+      const mapped = build.assetData.data.map(d => ({
+        title: d.title,
+        description: d.description,
+        filename: d.path,
+        tags: d.tags
+      }))
+      assert.equal(mapped.length, 2)
+      assert.equal(mapped[0].filename, 'assets/logo.png')
+      assert.equal(mapped[0].title, 'Logo')
+      assert.equal(mapped[0]._id, undefined)
+      assert.deepEqual(mapped[1].tags, [])
+    })
+
+    it('should not include assets for export when assetData is empty', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      build.assetData = { data: [] }
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: {} }
+      }
+      const data = Object.values(build.courseData)
+      if (build.isExport && build.assetData.data.length) {
+        data.push(build.assetData)
+      }
+      assert.equal(data.length, 1)
+    })
+
+    it('should include asset data entry for non-empty export', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      build.assetData = { data: [{ title: 'img', path: 'a.png' }] }
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: {} }
+      }
+      const data = Object.values(build.courseData)
+      if (build.isExport && build.assetData.data.length) {
+        data.push(build.assetData)
+      }
+      assert.equal(data.length, 2)
+    })
   })
 })

package/tests/AdaptFrameworkImport.spec.js

@@ -26,4 +26,302 @@ describe('AdaptFrameworkImport', () => {
       assert.equal(AdaptFrameworkImport.typeToSchema({ _type: 'block' }), 'block')
     })
   })
+
+  describe('#getSortedData()', () => {
+    const getSortedData = AdaptFrameworkImport.prototype.getSortedData
+
+    it('should sort a simple course hierarchy into levels', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' },
+            art1: { _id: 'art1', _parentId: 'page1' },
+            block1: { _id: 'block1', _parentId: 'art1' }
+          }
+        }
+      }
+      const { sorted, hierarchy } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 3)
+      assert.deepEqual(sorted[0], ['page1'])
+      assert.deepEqual(sorted[1], ['art1'])
+      assert.deepEqual(sorted[2], ['block1'])
+      assert.ok(hierarchy)
+    })
+
+    it('should group siblings at the same level', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' },
+            page2: { _id: 'page2', _parentId: 'course1' },
+            art1: { _id: 'art1', _parentId: 'page1' },
+            art2: { _id: 'art2', _parentId: 'page2' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 2)
+      assert.equal(sorted[0].length, 2)
+      assert.ok(sorted[0].includes('page1'))
+      assert.ok(sorted[0].includes('page2'))
+      assert.equal(sorted[1].length, 2)
+      assert.ok(sorted[1].includes('art1'))
+      assert.ok(sorted[1].includes('art2'))
+    })
+
+    it('should not include course in the sorted output', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      const allIds = sorted.flat()
+      assert.ok(!allIds.includes('course1'))
+    })
+
+    it('should build correct hierarchy map', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' },
+            page2: { _id: 'page2', _parentId: 'course1' },
+            art1: { _id: 'art1', _parentId: 'page1' }
+          }
+        }
+      }
+      const { hierarchy } = getSortedData.call(ctx)
+      assert.deepEqual(hierarchy.course1, ['page1', 'page2'])
+      assert.deepEqual(hierarchy.page1, ['art1'])
+    })
+
+    it('should handle deep nesting (5 levels)', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'c' },
+          contentObjects: {
+            p: { _id: 'p', _parentId: 'c' },
+            a: { _id: 'a', _parentId: 'p' },
+            b: { _id: 'b', _parentId: 'a' },
+            x: { _id: 'x', _parentId: 'b' },
+            y: { _id: 'y', _parentId: 'x' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 5)
+      assert.deepEqual(sorted[0], ['p'])
+      assert.deepEqual(sorted[1], ['a'])
+      assert.deepEqual(sorted[2], ['b'])
+      assert.deepEqual(sorted[3], ['x'])
+      assert.deepEqual(sorted[4], ['y'])
+    })
+
+    it('should handle a single page', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'c' },
+          contentObjects: {
+            p: { _id: 'p', _parentId: 'c' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 1)
+      assert.deepEqual(sorted[0], ['p'])
+    })
+  })
+
+  describe('#extractAssets()', () => {
+    function makeCtx (assetMap) {
+      const ctx = { assetMap }
+      ctx.extractAssets = AdaptFrameworkImport.prototype.extractAssets.bind(ctx)
+      return ctx
+    }
+
+    it('should replace asset paths with mapped IDs', () => {
+      const ctx = makeCtx({ 'course/en/assets/logo.png': 'asset123' })
+      const schema = {
+        _graphic: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+      const data = { _graphic: { src: 'course/en/assets/logo.png' } }
+      ctx.extractAssets(schema, data)
+      assert.equal(data._graphic.src, 'asset123')
+    })
+
+    it('should delete empty string asset values', () => {
+      const ctx = makeCtx({})
+      const schema = {
+        _graphic: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+      const data = { _graphic: { src: '' } }
+      ctx.extractAssets(schema, data)
+      assert.equal('src' in data._graphic, false)
+    })
+
+    it('should keep value when not in assetMap', () => {
+      const ctx = makeCtx({})
+      const schema = {
+        img: { _backboneForms: { type: 'Asset' } }
+      }
+      const data = { img: 'unknown/path.png' }
+      ctx.extractAssets(schema, data)
+      assert.equal(data.img, 'unknown/path.png')
+    })
+
+    it('should recurse into nested properties', () => {
+      const ctx = makeCtx({ 'assets/bg.jpg': 'asset456' })
+      const schema = {
+        _settings: {
+          properties: {
+            _background: {
+              properties: {
+                src: { _backboneForms: 'Asset' }
+              }
+            }
+          }
+        }
+      }
+      const data = { _settings: { _background: { src: 'assets/bg.jpg' } } }
+      ctx.extractAssets(schema, data)
+      assert.equal(data._settings._background.src, 'asset456')
+    })
+
+    it('should recurse into array items', () => {
+      const ctx = makeCtx({ 'assets/a.png': 'id1', 'assets/b.png': 'id2' })
+      const schema = {
+        _items: {
+          items: {
+            properties: {
+              src: { _backboneForms: 'Asset' }
+            }
+          }
+        }
+      }
+      const data = {
+        _items: [
+          { src: 'assets/a.png' },
+          { src: 'assets/b.png' }
+        ]
+      }
+      ctx.extractAssets(schema, data)
+      assert.equal(data._items[0].src, 'id1')
+      assert.equal(data._items[1].src, 'id2')
+    })
+
+    it('should skip undefined data keys', () => {
+      const ctx = makeCtx({})
+      const schema = {
+        _graphic: { _backboneForms: 'Asset' }
+      }
+      const data = {}
+      ctx.extractAssets(schema, data)
+      assert.equal('_graphic' in data, false)
+    })
+
+    it('should handle null schema gracefully', () => {
+      const ctx = makeCtx({})
+      ctx.extractAssets(null, { a: 1 })
+    })
+
+    it('should handle _backboneForms as object with type', () => {
+      const ctx = makeCtx({ 'path/img.png': 'mapped' })
+      const schema = {
+        hero: { _backboneForms: { type: 'Asset' } }
+      }
+      const data = { hero: 'path/img.png' }
+      ctx.extractAssets(schema, data)
+      assert.equal(data.hero, 'mapped')
+    })
+  })
+
+  describe('#loadContentFile()', () => {
+    /**
+     * loadContentFile depends on FWUtils.readJson (file I/O) and App.instance,
+     * but we can test the classification logic by providing a mock.
+     * We extract and test the classification behaviour inline.
+     */
+    it('should classify course type into contentJson.course', () => {
+      const classify = (contents, filePath, ctx) => {
+        if (contents._type === 'course') {
+          ctx.contentJson.course = contents
+          return
+        }
+        if (filePath.endsWith('config.json')) {
+          ctx.contentJson.config = { _id: 'config', _type: 'config', ...contents }
+          return
+        }
+        if (Array.isArray(contents)) {
+          contents.forEach(c => {
+            ctx.contentJson.contentObjects[c._id] = c
+          })
+        }
+      }
+      const ctx = { contentJson: { course: {}, config: {}, contentObjects: {} } }
+      classify({ _type: 'course', title: 'My Course' }, 'en/course.json', ctx)
+      assert.equal(ctx.contentJson.course.title, 'My Course')
+    })
+
+    it('should classify config.json as config with defaults', () => {
+      const classify = (contents, filePath, ctx) => {
+        if (contents._type === 'course') {
+          ctx.contentJson.course = contents
+          return
+        }
+        if (filePath.endsWith('config.json')) {
+          ctx.contentJson.config = { _id: 'config', _type: 'config', ...contents }
+          return
+        }
+        if (Array.isArray(contents)) {
+          contents.forEach(c => {
+            ctx.contentJson.contentObjects[c._id] = c
+          })
+        }
+      }
+      const ctx = { contentJson: { course: {}, config: {}, contentObjects: {} } }
+      classify({ _defaultLanguage: 'en' }, 'course/config.json', ctx)
+      assert.equal(ctx.contentJson.config._id, 'config')
+      assert.equal(ctx.contentJson.config._type, 'config')
+      assert.equal(ctx.contentJson.config._defaultLanguage, 'en')
+    })
+
+    it('should store array contents into contentObjects by _id', () => {
+      const classify = (contents, filePath, ctx) => {
+        if (contents._type === 'course') {
+          ctx.contentJson.course = contents
+          return
+        }
+        if (filePath.endsWith('config.json')) {
+          ctx.contentJson.config = { _id: 'config', _type: 'config', ...contents }
+          return
+        }
+        if (Array.isArray(contents)) {
+          contents.forEach(c => {
+            ctx.contentJson.contentObjects[c._id] = c
+          })
+        }
+      }
+      const ctx = { contentJson: { course: {}, config: {}, contentObjects: {} } }
+      classify([
+        { _id: 'page1', _type: 'page' },
+        { _id: 'art1', _type: 'article' }
+      ], 'en/contentObjects.json', ctx)
+      assert.equal(ctx.contentJson.contentObjects.page1._type, 'page')
+      assert.equal(ctx.contentJson.contentObjects.art1._type, 'article')
+    })
+  })
 })

package/tests/AdaptFrameworkUtils.spec.js

@@ -20,11 +20,8 @@ describe('AdaptFrameworkUtils', () => {
       })
     })
 
-    // TODO: inferBuildAction returns truncated result for URLs without a second slash
-    // e.g. '/import' returns 'impor' because indexOf('/', 1) returns -1
-    // causing slice(1, -1) to strip the last character
-    it('should truncate action for URLs without trailing slash/path (known bug)', () => {
-      assert.equal(AdaptFrameworkUtils.inferBuildAction({ url: '/import' }), 'impor')
+    it('should return full action for URLs without trailing slash', () => {
+      assert.equal(AdaptFrameworkUtils.inferBuildAction({ url: '/import' }), 'import')
     })
   })
 

package/tests/migrations.spec.js

@@ -0,0 +1,394 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+import ConfigTransform from '../lib/migrations/config.js'
+import GraphicSrcTransform from '../lib/migrations/graphic-src.js'
+import NavOrderTransform from '../lib/migrations/nav-order.js'
+import ParentIdTransform from '../lib/migrations/parent-id.js'
+import RemoveUndef from '../lib/migrations/remove-undef.js'
+import StartPage from '../lib/migrations/start-page.js'
+import ThemeUndef from '../lib/migrations/theme-undef.js'
+
+describe('Migrations', () => {
+  describe('ConfigTransform', () => {
+    it('should convert numeric ARIA levels to strings', async () => {
+      const data = {
+        _type: 'config',
+        _accessibility: {
+          _ariaLevels: {
+            _menu: 1,
+            _menuItem: 2,
+            _page: 3,
+            _article: 4,
+            _block: 5,
+            _component: 6,
+            _componentItem: 7,
+            _notify: 8
+          }
+        }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, '1')
+      assert.equal(data._accessibility._ariaLevels._menuItem, '2')
+      assert.equal(data._accessibility._ariaLevels._page, '3')
+      assert.equal(data._accessibility._ariaLevels._article, '4')
+      assert.equal(data._accessibility._ariaLevels._block, '5')
+      assert.equal(data._accessibility._ariaLevels._component, '6')
+      assert.equal(data._accessibility._ariaLevels._componentItem, '7')
+      assert.equal(data._accessibility._ariaLevels._notify, '8')
+    })
+
+    it('should not modify already-string values', async () => {
+      const data = {
+        _type: 'config',
+        _accessibility: { _ariaLevels: { _menu: '1' } }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, '1')
+    })
+
+    it('should skip non-config types', async () => {
+      const data = {
+        _type: 'course',
+        _accessibility: { _ariaLevels: { _menu: 1 } }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, 1)
+    })
+
+    it('should skip config without _ariaLevels', async () => {
+      const data = { _type: 'config', _accessibility: {} }
+      await ConfigTransform(data)
+      assert.deepEqual(data._accessibility, {})
+    })
+
+    it('should not convert falsy values (0)', async () => {
+      const data = {
+        _type: 'config',
+        _accessibility: { _ariaLevels: { _menu: 0 } }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, 0)
+    })
+  })
+
+  describe('GraphicSrcTransform', () => {
+    it('should copy src to large and small for graphic component', async () => {
+      const data = {
+        _component: 'adapt-contrib-graphic',
+        _graphic: { src: 'image.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'image.png')
+      assert.equal(data._graphic.small, 'image.png')
+    })
+
+    it('should copy src to large and small for hotgraphic component', async () => {
+      const data = {
+        _component: 'adapt-contrib-hotgraphic',
+        _graphic: { src: 'hot.png' },
+        _items: [
+          { _graphic: { src: 'item1.png' } },
+          { _graphic: { src: 'item2.png' } }
+        ]
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'hot.png')
+      assert.equal(data._graphic.small, 'hot.png')
+      assert.equal(data._items[0]._graphic.large, 'item1.png')
+      assert.equal(data._items[0]._graphic.small, 'item1.png')
+      assert.equal(data._items[1]._graphic.large, 'item2.png')
+      assert.equal(data._items[1]._graphic.small, 'item2.png')
+    })
+
+    it('should skip non-graphic components', async () => {
+      const data = {
+        _component: 'adapt-contrib-text',
+        _graphic: { src: 'image.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, undefined)
+    })
+
+    it('should not overwrite if src is absent', async () => {
+      const data = {
+        _component: 'adapt-contrib-graphic',
+        _graphic: { large: 'existing.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'existing.png')
+    })
+
+    it('should handle graphic without _items', async () => {
+      const data = {
+        _component: 'adapt-contrib-graphic',
+        _graphic: { src: 'only.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'only.png')
+      assert.equal(data._graphic.small, 'only.png')
+    })
+  })
+
+  describe('NavOrderTransform', () => {
+    it('should convert string _navOrder to number', async () => {
+      const data = {
+        _type: 'course',
+        _globals: {
+          _extensions: {
+            _trickle: { _navOrder: '100' },
+            _resources: { _navOrder: '200' }
+          }
+        }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, 100)
+      assert.equal(data._globals._extensions._resources._navOrder, 200)
+    })
+
+    it('should keep numeric _navOrder as-is', async () => {
+      const data = {
+        _type: 'course',
+        _globals: { _extensions: { _trickle: { _navOrder: 50 } } }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, 50)
+    })
+
+    it('should skip non-course types', async () => {
+      const data = {
+        _type: 'config',
+        _globals: { _extensions: { _trickle: { _navOrder: '100' } } }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, '100')
+    })
+
+    it('should skip extensions without _navOrder', async () => {
+      const data = {
+        _type: 'course',
+        _globals: { _extensions: { _trickle: { other: 'value' } } }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, undefined)
+    })
+  })
+
+  describe('ParentIdTransform', () => {
+    it('should remap _parentId using idMap', async () => {
+      const data = { _parentId: 'old-id' }
+      const importer = { idMap: { 'old-id': 'new-id' } }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, 'new-id')
+    })
+
+    it('should set _parentId to undefined when not in idMap', async () => {
+      const data = { _parentId: 'unknown' }
+      const importer = { idMap: {} }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, undefined)
+    })
+
+    it('should skip when _parentId is falsy', async () => {
+      const data = { _parentId: undefined }
+      const importer = { idMap: { undefined: 'should-not-set' } }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, undefined)
+    })
+
+    it('should skip when _parentId is not present', async () => {
+      const data = { _type: 'course' }
+      const importer = { idMap: {} }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, undefined)
+    })
+  })
+
+  describe('RemoveUndef', () => {
+    it('should remove null properties', async () => {
+      const data = { a: 1, b: null, c: 'test' }
+      await RemoveUndef(data)
+      assert.equal(data.a, 1)
+      assert.equal(data.c, 'test')
+      assert.equal('b' in data, false)
+    })
+
+    it('should recursively remove nulls in nested objects', async () => {
+      const data = { a: { b: null, c: { d: null, e: 1 } } }
+      await RemoveUndef(data)
+      assert.equal('b' in data.a, false)
+      assert.equal('d' in data.a.c, false)
+      assert.equal(data.a.c.e, 1)
+    })
+
+    it('should not recurse into arrays', async () => {
+      const data = { arr: [null, 1, null] }
+      await RemoveUndef(data)
+      assert.deepEqual(data.arr, [null, 1, null])
+    })
+
+    it('should preserve non-null falsy values', async () => {
+      const data = { a: 0, b: false, c: '', d: undefined }
+      await RemoveUndef(data)
+      assert.equal(data.a, 0)
+      assert.equal(data.b, false)
+      assert.equal(data.c, '')
+      assert.equal(data.d, undefined)
+    })
+
+    it('should handle empty object', async () => {
+      const data = {}
+      await RemoveUndef(data)
+      assert.deepEqual(data, {})
+    })
+
+    it('should handle deeply nested nulls', async () => {
+      const data = { a: { b: { c: { d: null } } } }
+      await RemoveUndef(data)
+      assert.equal('d' in data.a.b.c, false)
+    })
+  })
+
+  describe('StartPage', () => {
+    it('should assign _friendlyId to content objects from _startIds', async () => {
+      const data = {
+        _type: 'course',
+        _start: {
+          _startIds: [
+            { _id: 'page1' },
+            { _id: 'page2' }
+          ]
+        }
+      }
+      const importer = {
+        contentJson: {
+          contentObjects: {
+            page1: { _id: 'page1' },
+            page2: { _id: 'page2' }
+          }
+        },
+        framework: { log: mock.fn() }
+      }
+      await StartPage(data, importer)
+      assert.equal(importer.contentJson.contentObjects.page1._friendlyId, 'start_page_1')
+      assert.equal(importer.contentJson.contentObjects.page2._friendlyId, 'start_page_2')
+    })
+
+    it('should preserve existing _friendlyId', async () => {
+      const data = {
+        _type: 'course',
+        _start: {
+          _startIds: [{ _id: 'page1' }]
+        }
+      }
+      const importer = {
+        contentJson: {
+          contentObjects: {
+            page1: { _id: 'page1', _friendlyId: 'my-custom-id' }
+          }
+        },
+        framework: { log: mock.fn() }
+      }
+      await StartPage(data, importer)
+      assert.equal(importer.contentJson.contentObjects.page1._friendlyId, 'my-custom-id')
+      assert.equal(data._start._startIds[0]._id, 'my-custom-id')
+    })
+
+    it('should log warning for missing content object', async () => {
+      const logFn = mock.fn()
+      const data = {
+        _type: 'course',
+        _start: {
+          _startIds: [{ _id: 'missing' }]
+        }
+      }
+      const importer = {
+        contentJson: { contentObjects: {} },
+        framework: { log: logFn }
+      }
+      await StartPage(data, importer)
+      assert.equal(logFn.mock.calls.length, 1)
+      assert.equal(logFn.mock.calls[0].arguments[0], 'warn')
+    })
+
+    it('should skip non-course types', async () => {
+      const data = { _type: 'config', _start: { _startIds: [{ _id: 'p1' }] } }
+      const importer = { contentJson: { contentObjects: {} } }
+      await StartPage(data, importer)
+    })
+
+    it('should skip when _start is undefined', async () => {
+      const data = { _type: 'course' }
+      await StartPage(data, {})
+    })
+
+    it('should update _startIds[i]._id to match _friendlyId', async () => {
+      const data = {
+        _type: 'course',
+        _start: { _startIds: [{ _id: 'page1' }] }
+      }
+      const importer = {
+        contentJson: {
+          contentObjects: { page1: { _id: 'page1' } }
+        },
+        framework: { log: mock.fn() }
+      }
+      await StartPage(data, importer)
+      assert.equal(data._start._startIds[0]._id, 'start_page_1')
+    })
+  })
+
+  describe('ThemeUndef', () => {
+    it('should set _theme from used plugins when undefined', async () => {
+      const data = { _type: 'config' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-vanilla': { name: 'adapt-contrib-vanilla', type: 'theme' },
+          'adapt-contrib-text': { name: 'adapt-contrib-text', type: 'component' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, 'adapt-contrib-vanilla')
+    })
+
+    it('should not override existing _theme', async () => {
+      const data = { _type: 'config', _theme: 'my-theme' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-vanilla': { name: 'adapt-contrib-vanilla', type: 'theme' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, 'my-theme')
+    })
+
+    it('should skip non-config types', async () => {
+      const data = { _type: 'course' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-vanilla': { name: 'adapt-contrib-vanilla', type: 'theme' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, undefined)
+    })
+
+    it('should set _theme to undefined when no theme plugin found', async () => {
+      const data = { _type: 'config' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-text': { name: 'adapt-contrib-text', type: 'component' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, undefined)
+    })
+
+    it('should handle empty usedContentPlugins', async () => {
+      const data = { _type: 'config' }
+      const importer = { usedContentPlugins: {} }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, undefined)
+    })
+  })
+})