adapt-authoring-courseassets 1.1.0 → 1.2.0

package/lib/courseassetsModule.js

@@ -1,4 +1,5 @@
 import AbstractApiModule from 'adapt-authoring-api'
+import { extractAssetIds } from './utils.js'
 /**
  * Module which handles courseassets automatically using on content events
  * @memberof courseassets
@@ -46,29 +47,6 @@ class CourseAssetsModule extends AbstractApiModule {
     })
   }
 
-  /**
-   * Search data object for asset types and retrieve _ids
-   * @param {Object} data
-   */
-  extractAssetIds (schema, data, assets = []) {
-    Object.entries(schema).forEach(([key, val]) => {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
-        return
-      }
-      if (val.properties) {
-        this.extractAssetIds(val.properties, data[key], assets)
-      } else if (val?.items?.properties) {
-        data[key].forEach(d => this.extractAssetIds(val.items.properties, d, assets))
-      } else if ((val?._backboneForms?.type === 'Asset' || val?._backboneForms === 'Asset') && data[key]) {
-        const v = data[key].toString()
-        if (!v.startsWith('http://') && !v.startsWith('https://')) {
-          assets.push(v)
-        }
-      }
-    })
-    return Array.from(new Set(assets))
-  };
-
   /**
    * Handler for content event
    * @param {String} action The action performed
@@ -96,7 +74,7 @@ class CourseAssetsModule extends AbstractApiModule {
 
     const data = isModify ? arg2 : arg1
     const schema = await this.content.getSchema(this.content.schemaName, data)
-    const ids = this.extractAssetIds(schema.built.properties, data)
+    const ids = extractAssetIds(schema.built.properties, data)
 
     if (!ids.length) {
       return

package/lib/utils/extractAssetIds.js

@@ -0,0 +1,26 @@
+/**
+ * Searches a data object for asset-type schema properties and collects their IDs
+ * @param {Object} schema The schema properties to traverse
+ * @param {Object} data The data object to search for asset values
+ * @param {Array<String>} assets Accumulator array for found asset IDs
+ * @return {Array<String>} Unique array of asset IDs found in the data
+ * @memberof courseassets
+ */
+export function extractAssetIds (schema, data, assets = []) {
+  Object.entries(schema).forEach(([key, val]) => {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      return
+    }
+    if (val.properties) {
+      extractAssetIds(val.properties, data[key], assets)
+    } else if (val?.items?.properties) {
+      data[key].forEach(d => extractAssetIds(val.items.properties, d, assets))
+    } else if ((val?._backboneForms?.type === 'Asset' || val?._backboneForms === 'Asset') && data[key]) {
+      const v = data[key].toString()
+      if (!v.startsWith('http://') && !v.startsWith('https://')) {
+        assets.push(v)
+      }
+    }
+  })
+  return Array.from(new Set(assets))
+}

package/lib/utils.js

@@ -0,0 +1 @@
+export { extractAssetIds } from './utils/extractAssetIds.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-courseassets",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Module for managing courseassets",
   "homepage": "https://github.com/deltanetdan/adapt-authoring-courseassets",
   "license": "GPL-3.0",
@@ -10,7 +10,7 @@
   "peerDependencies": {
     "adapt-authoring-assets": "^1.3.1",
     "adapt-authoring-content": "^1.2.3",
-    "adapt-authoring-core": "^1.7.0"
+    "adapt-authoring-core": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "adapt-authoring-assets": {

package/tests/utils-extractAssetIds.spec.js

@@ -0,0 +1,112 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { extractAssetIds } from '../lib/utils/extractAssetIds.js'
+
+describe('extractAssetIds()', () => {
+  it('should return empty array when no asset fields exist', () => {
+    const schema = { title: { type: 'string' } }
+    const data = { title: 'test' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should extract asset ID from _backboneForms Asset string type', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'abc123' }
+    assert.deepEqual(extractAssetIds(schema, data), ['abc123'])
+  })
+
+  it('should extract asset ID from _backboneForms.type Asset', () => {
+    const schema = { image: { _backboneForms: { type: 'Asset' } } }
+    const data = { image: 'abc123' }
+    assert.deepEqual(extractAssetIds(schema, data), ['abc123'])
+  })
+
+  it('should skip keys not present in data', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = {}
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should skip falsy asset values', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: '' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should skip HTTP URLs', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'http://example.com/image.png' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should skip HTTPS URLs', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'https://example.com/image.png' }
+    assert.deepEqual(extractAssetIds(schema, data), [])
+  })
+
+  it('should recurse into nested schema properties', () => {
+    const schema = {
+      _graphic: {
+        properties: {
+          src: { _backboneForms: 'Asset' }
+        }
+      }
+    }
+    const data = { _graphic: { src: 'img123' } }
+    assert.deepEqual(extractAssetIds(schema, data), ['img123'])
+  })
+
+  it('should recurse into array items with properties', () => {
+    const schema = {
+      _items: {
+        items: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+    }
+    const data = { _items: [{ src: 'a1' }, { src: 'a2' }] }
+    assert.deepEqual(extractAssetIds(schema, data), ['a1', 'a2'])
+  })
+
+  it('should deduplicate asset IDs', () => {
+    const schema = {
+      _items: {
+        items: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+    }
+    const data = { _items: [{ src: 'same' }, { src: 'same' }] }
+    assert.deepEqual(extractAssetIds(schema, data), ['same'])
+  })
+
+  it('should accumulate with provided assets array', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: 'new1' }
+    const existing = ['existing1']
+    const result = extractAssetIds(schema, data, existing)
+    assert.ok(result.includes('existing1'))
+    assert.ok(result.includes('new1'))
+  })
+
+  it('should handle toString on non-string asset values', () => {
+    const schema = { image: { _backboneForms: 'Asset' } }
+    const data = { image: { toString: () => 'obj123' } }
+    assert.deepEqual(extractAssetIds(schema, data), ['obj123'])
+  })
+
+  it('should handle multiple asset fields at the same level', () => {
+    const schema = {
+      image1: { _backboneForms: 'Asset' },
+      image2: { _backboneForms: { type: 'Asset' } },
+      title: { type: 'string' }
+    }
+    const data = { image1: 'a1', image2: 'a2', title: 'test' }
+    assert.deepEqual(extractAssetIds(schema, data), ['a1', 'a2'])
+  })
+})