scandit-datacapture-frameworks-core 8.2.1 → 8.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scandit-datacapture-frameworks-core",
-  "version": "8.2.1",
+  "version": "8.3.0",
   "description": "Core common package",
   "author": {
     "name": "Scandit",
@@ -10,10 +10,10 @@
   "main": "dist/index.js",
   "types": "dist/dts/index.d.ts",
   "scripts": {
-    "build": "rollup -c rollup.config.js --bundleConfigAsCjs",
+    "build": "rollup -c ../../../rollup.config.js --bundleConfigAsCjs",
     "clean": "rimraf .rollup.cache dist",
     "lint": "eslint ./src",
-    "prepack": "pnpm run build",
+    "prepack": "rollup -c ../../../rollup.config.js --bundleConfigAsCjs",
     "test": "jest --passWithNoTests",
     "coverage": "jest --coverage --passWithNoTests"
   },

package/test/CameraSettings.test.ts

@@ -0,0 +1,335 @@
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { CameraSettings } from '../src';
+import { parseDefaults } from '../src/defaults/CoreDefaults';
+import { FocusRange } from '../src/camera/FocusRange';
+import { FocusGestureStrategy } from '../src/camera/FocusGestureStrategy';
+import { VideoResolution } from '../src/camera/VideoResolution';
+import { MacroMode } from '../src/camera/MacroMode';
+import { loadMockDefaults, mockCoreDefaultsData } from '../__mocks__/Defaults';
+
+beforeEach(() => {
+    loadMockDefaults();
+});
+
+describe('CameraSettings', () => {
+
+    describe('default constructor', () => {
+        it('initializes all fields from mock defaults', () => {
+            const settings = new CameraSettings();
+
+            expect(settings.preferredResolution).toBe(VideoResolution.Auto);
+            expect(settings.zoomFactor).toBe(1);
+            expect(settings.zoomGestureZoomFactor).toBe(2);
+            expect(settings.torchLevel).toBe(1);
+            expect(settings.macroMode).toBe('auto');
+            expect(settings.adaptiveExposure).toBe(false);
+        });
+
+        it('initializes focus sub-fields via getProperty', () => {
+            const settings = new CameraSettings();
+
+            expect(settings.focusRange).toBe('near');
+            expect(settings.focusGestureStrategy).toBe('manualUntilCapture');
+            expect(settings.shouldPreferSmoothAutoFocus).toBe(false);
+            // manualLensPosition and focusStrategy are optional — undefined until explicitly set
+            expect(settings.getProperty('manualLensPosition')).toBeUndefined();
+            expect(settings.getProperty('focusStrategy')).toBeUndefined();
+        });
+    });
+
+    describe('fromJSON — native format (flat top-level + properties bag)', () => {
+        // This is what Android and iOS actually send.
+        // Focus basics (focusRange, focusGestureStrategy, shouldPreferSmoothAutoFocus) are
+        // at the top level. manualLensPosition and focusStrategy come in the properties bag.
+        // iOS additionally sends "range" in properties (same value as focusRange).
+        it('deserializes top-level focus fields and properties bag', () => {
+            const json = {
+                preferredResolution: 'fullHd',
+                zoomFactor: 1.5,
+                zoomGestureZoomFactor: 3,
+                focusRange: 'full',
+                focusGestureStrategy: 'autoFocus',
+                shouldPreferSmoothAutoFocus: true,
+                macroMode: 'disabled',
+                adaptiveExposure: true,
+                torchLevel: 0.8,
+                properties: {
+                    range: 'full',           // iOS sends this (same as focusRange)
+                    manualLensPosition: 0.5,
+                    focusStrategy: 'autoFocus',
+                    overwriteWithHighestResolution: true,
+                },
+            };
+
+            const settings = (CameraSettings as any).fromJSON(json);
+
+            expect(settings.preferredResolution).toBe('fullHd');
+            expect(settings.zoomFactor).toBe(1.5);
+            expect(settings.zoomGestureZoomFactor).toBe(3);
+            expect(settings.macroMode).toBe('disabled');
+            expect(settings.adaptiveExposure).toBe(true);
+            expect(settings.torchLevel).toBe(0.8);
+
+            // All focus properties end up in the focus bag
+            expect(settings.focusRange).toBe('full');
+            expect(settings.focusGestureStrategy).toBe('autoFocus');
+            expect(settings.shouldPreferSmoothAutoFocus).toBe(true);
+            expect(settings.getProperty('range')).toBe('full');
+            expect(settings.getProperty('manualLensPosition')).toBe(0.5);
+            expect(settings.getProperty('focusStrategy')).toBe('autoFocus');
+            // Non-focus property goes to top-level field
+            expect(settings.getProperty('overwriteWithHighestResolution')).toBe(true);
+        });
+
+        it('focus properties from properties bag all route to the focus bag', () => {
+            const json = {
+                preferredResolution: 'auto',
+                zoomFactor: 1,
+                zoomGestureZoomFactor: 2,
+                properties: {
+                    range: 'near',
+                    manualLensPosition: 0.3,
+                    focusStrategy: 'onlyOnRequest',
+                    focusGestureStrategy: 'manualUntilCapture',
+                    shouldPreferSmoothAutoFocus: false,
+                },
+            };
+
+            const settings = (CameraSettings as any).fromJSON(json);
+
+            // All focusHiddenProperties members routed to focus bag regardless of source
+            expect(settings.getProperty('range')).toBe('near');
+            expect(settings.focusRange).toBe('near');
+            expect(settings.getProperty('manualLensPosition')).toBe(0.3);
+            expect(settings.getProperty('focusStrategy')).toBe('onlyOnRequest');
+            expect(settings.getProperty('focusGestureStrategy')).toBe('manualUntilCapture');
+            expect(settings.focusGestureStrategy).toBe('manualUntilCapture');
+            expect(settings.getProperty('shouldPreferSmoothAutoFocus')).toBe(false);
+            expect(settings.shouldPreferSmoothAutoFocus).toBe(false);
+        });
+    });
+
+    describe('fromJSON — Android format (no range in properties)', () => {
+        // Android CameraSettingsPropertiesDefaults does NOT include "range" in the properties bag.
+        // Only manualLensPosition and focusStrategy are sent. focus.range must come from
+        // the top-level focusRange field, and getProperty('range') must stay consistent.
+        it('sets focus.range from top-level focusRange when range is absent from properties', () => {
+            const json = {
+                preferredResolution: 'auto',
+                zoomFactor: 1,
+                zoomGestureZoomFactor: 2,
+                focusRange: 'full',
+                focusGestureStrategy: 'manualUntilCapture',
+                shouldPreferSmoothAutoFocus: false,
+                macroMode: 'auto',
+                adaptiveExposure: false,
+                torchLevel: 1,
+                properties: {
+                    manualLensPosition: 0.2,
+                    focusStrategy: 'onlyOnRequest',
+                    // no "range" key — Android does not send it
+                },
+            };
+
+            const settings = (CameraSettings as any).fromJSON(json);
+
+            expect(settings.focusRange).toBe('full');
+            // getProperty('range') reads from the same focus bag as focusRange
+            expect(settings.getProperty('range')).toBe('full');
+            expect(settings.getProperty('manualLensPosition')).toBe(0.2);
+            expect(settings.getProperty('focusStrategy')).toBe('onlyOnRequest');
+        });
+    });
+
+    describe('fromJSON — sparse properties bag (null-filtered by native)', () => {
+        // Both Android and iOS filter null values from the properties bag before sending.
+        // When manualLensPosition or focusStrategy are null on the native side, they are
+        // absent from properties entirely. The TS side must fall back to coreDefaults.
+        it('leaves manualLensPosition and focusStrategy as undefined when absent from properties', () => {
+            const json = {
+                preferredResolution: 'auto',
+                zoomFactor: 1,
+                zoomGestureZoomFactor: 2,
+                properties: {
+                    // manualLensPosition and focusStrategy absent (filtered as null by native)
+                    overwriteWithHighestResolution: false,
+                },
+            };
+
+            const settings = (CameraSettings as any).fromJSON(json);
+
+            // Not present in properties bag — remain undefined (not defaulted from coreDefaults)
+            expect(settings.getProperty('manualLensPosition')).toBeUndefined();
+            expect(settings.getProperty('focusStrategy')).toBeUndefined();
+        });
+
+        it('leaves focus basics as undefined when top-level focus fields are absent from JSON', () => {
+            // In practice native always sends these fields, but when absent fromJSON does not
+            // fall back to defaults — callers are expected to provide them.
+            const json = {
+                preferredResolution: 'auto',
+                zoomFactor: 1,
+                zoomGestureZoomFactor: 2,
+                properties: {},
+            };
+
+            const settings = (CameraSettings as any).fromJSON(json);
+
+            expect(settings.focusRange).toBeUndefined();
+            expect(settings.focusGestureStrategy).toBeUndefined();
+            expect(settings.shouldPreferSmoothAutoFocus).toBeUndefined();
+        });
+    });
+
+    describe('parseDefaults — new fields with fallbacks', () => {
+        // parseDefaults (CoreDefaults.ts) applies hardcoded fallbacks for fields introduced
+        // after the initial release. Older native builds may omit torchLevel, macroMode,
+        // adaptiveExposure, manualLensPosition, focusStrategy from the defaults JSON.
+        // Tested via parseDefaults directly since loadCoreDefaults uses bindInstanceIfNotExists
+        // and won't replace already-loaded defaults.
+        it('uses hardcoded fallbacks when new fields are absent from native defaults JSON', () => {
+            // Build from the full mock so parseDefaults has all the sections it needs,
+            // then strip the new Camera.Settings fields to simulate an older native build.
+            const { torchLevel, macroMode, adaptiveExposure, manualLensPosition, focusStrategy, ...oldSettings } =
+                mockCoreDefaultsData.Camera.Settings;
+            const oldNativeData = {
+                ...mockCoreDefaultsData,
+                Camera: { ...mockCoreDefaultsData.Camera, Settings: oldSettings },
+            };
+
+            const defaults = parseDefaults(oldNativeData);
+
+            expect(defaults.Camera.Settings.torchLevel).toBe(1.0);        // ?? 1.0
+            expect(defaults.Camera.Settings.macroMode).toBe('auto');       // ?? 'auto'
+            expect(defaults.Camera.Settings.adaptiveExposure).toBe(false); // ?? false
+            expect(defaults.Camera.Settings.manualLensPosition).toBe(0);   // ?? 0
+            expect(defaults.Camera.Settings.focusStrategy).toBe('auto'); // ?? 'auto'
+        });
+
+        it('reads new fields when present in native defaults JSON', () => {
+            const newNativeData = {
+                ...mockCoreDefaultsData,
+                Camera: {
+                    ...mockCoreDefaultsData.Camera,
+                    Settings: {
+                        ...mockCoreDefaultsData.Camera.Settings,
+                        torchLevel: 0.5,
+                        macroMode: 'disabled',
+                        adaptiveExposure: true,
+                        manualLensPosition: 0.8,
+                        focusStrategy: 'autoFocus',
+                    },
+                },
+            };
+
+            const defaults = parseDefaults(newNativeData);
+
+            expect(defaults.Camera.Settings.torchLevel).toBe(0.5);
+            expect(defaults.Camera.Settings.macroMode).toBe('disabled');
+            expect(defaults.Camera.Settings.adaptiveExposure).toBe(true);
+            expect(defaults.Camera.Settings.manualLensPosition).toBe(0.8);
+            expect(defaults.Camera.Settings.focusStrategy).toBe('autoFocus');
+        });
+    });
+
+    describe('fromJSON — missing optional fields fall back to defaults', () => {
+        it('does not crash when focus, properties, and optional fields are all absent', () => {
+            const json = {
+                preferredResolution: 'auto',
+                zoomFactor: 1,
+                zoomGestureZoomFactor: 2,
+            };
+
+            expect(() => (CameraSettings as any).fromJSON(json)).not.toThrow();
+        });
+
+        it('uses defaults for macroMode, adaptiveExposure, torchLevel when absent', () => {
+            const json = {
+                preferredResolution: 'auto',
+                zoomFactor: 1,
+                zoomGestureZoomFactor: 2,
+            };
+
+            const settings = (CameraSettings as any).fromJSON(json);
+
+            expect(settings.torchLevel).toBe(1);
+            expect(settings.macroMode).toBe('auto');
+            expect(settings.adaptiveExposure).toBe(false);
+        });
+
+        it('leaves all focus fields as undefined when both focus object and top-level focus fields are absent', () => {
+            const json = {
+                preferredResolution: 'auto',
+                zoomFactor: 1,
+                zoomGestureZoomFactor: 2,
+            };
+
+            const settings = (CameraSettings as any).fromJSON(json);
+
+            expect(settings.focusRange).toBeUndefined();
+            expect(settings.focusGestureStrategy).toBeUndefined();
+            expect(settings.shouldPreferSmoothAutoFocus).toBeUndefined();
+            expect(settings.getProperty('manualLensPosition')).toBeUndefined();
+            expect(settings.getProperty('focusStrategy')).toBeUndefined();
+        });
+    });
+
+    describe('setProperty / getProperty', () => {
+        it('routes all focusHiddenProperties to the focus bag', () => {
+            const settings = new CameraSettings();
+
+            settings.setProperty('range', 'infinite' as FocusRange);
+            settings.setProperty('manualLensPosition', 0.75);
+            settings.setProperty('focusStrategy', 'autoFocus');
+            settings.setProperty('focusGestureStrategy', 'manual' as FocusGestureStrategy);
+            settings.setProperty('shouldPreferSmoothAutoFocus', true);
+
+            expect(settings.getProperty('range')).toBe('infinite');
+            expect(settings.getProperty('manualLensPosition')).toBe(0.75);
+            expect(settings.getProperty('focusStrategy')).toBe('autoFocus');
+            expect(settings.getProperty('focusGestureStrategy')).toBe('manual');
+            expect(settings.getProperty('shouldPreferSmoothAutoFocus')).toBe(true);
+
+            // Public accessors also reflect the updated values
+            expect(settings.focusRange).toBe('infinite');
+            expect(settings.focusGestureStrategy).toBe('manual');
+            expect(settings.shouldPreferSmoothAutoFocus).toBe(true);
+        });
+
+        it('routes non-focus properties to top-level fields', () => {
+            const settings = new CameraSettings();
+
+            settings.setProperty('zoomFactor', 3.5);
+
+            expect(settings.getProperty('zoomFactor')).toBe(3.5);
+            expect(settings.zoomFactor).toBe(3.5);
+        });
+    });
+
+    describe('copy constructor', () => {
+        it('copies all settings including focus sub-fields', () => {
+            const original = new CameraSettings();
+            original.zoomFactor = 2.5;
+            original.torchLevel = 0.5;
+            original.macroMode = 'disabled' as MacroMode;
+            original.adaptiveExposure = true;
+            original.focusRange = 'far' as FocusRange;
+            original.focusGestureStrategy = 'autoFocus' as FocusGestureStrategy;
+            original.shouldPreferSmoothAutoFocus = true;
+            original.setProperty('manualLensPosition', 0.3);
+            original.setProperty('focusStrategy', 'autoFocus');
+
+            const copy = new CameraSettings(original);
+
+            expect(copy.zoomFactor).toBe(2.5);
+            expect(copy.torchLevel).toBe(0.5);
+            expect(copy.macroMode).toBe('disabled');
+            expect(copy.adaptiveExposure).toBe(true);
+            expect(copy.focusRange).toBe('far');
+            expect(copy.focusGestureStrategy).toBe('autoFocus');
+            expect(copy.shouldPreferSmoothAutoFocus).toBe(true);
+            expect(copy.getProperty('manualLensPosition')).toBe(0.3);
+            expect(copy.getProperty('focusStrategy')).toBe('autoFocus');
+        });
+    });
+});

package/test/Color.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from '@jest/globals';
+import { Color } from '../src/common/Color';
+
+describe('Color', () => {
+  describe('fromHex', () => {
+    it('parses a hex string with # prefix correctly', () => {
+      const color = Color.fromHex('#FF8040FF');
+      expect(color.red).toBe(0xff);
+      expect(color.green).toBe(0x80);
+      expect(color.blue).toBe(0x40);
+      expect(color.alpha).toBe(0xff);
+    });
+
+    it('parses a hex string without # prefix correctly', () => {
+      const color = Color.fromHex('FF8040FF');
+      expect(color.red).toBe(0xff);
+      expect(color.green).toBe(0x80);
+      expect(color.blue).toBe(0x40);
+      expect(color.alpha).toBe(0xff);
+    });
+
+    it('adds default full alpha when alpha is omitted', () => {
+      const color = Color.fromHex('#FF8040');
+      expect(color.red).toBe(0xff);
+      expect(color.green).toBe(0x80);
+      expect(color.blue).toBe(0x40);
+      expect(color.alpha).toBe(0xff);
+    });
+
+    it('expands shorthand 3-digit hex', () => {
+      const color = Color.fromHex('#F80');
+      expect(color.red).toBe(0xff);
+      expect(color.green).toBe(0x88);
+      expect(color.blue).toBe(0x00);
+      expect(color.alpha).toBe(0xff);
+    });
+  });
+
+  describe('fromRGBA', () => {
+    it('creates color from integer RGBA components', () => {
+      const color = Color.fromRGBA(255, 128, 64, 255);
+      expect(color.red).toBe(255);
+      expect(color.green).toBe(128);
+      expect(color.blue).toBe(64);
+      expect(color.alpha).toBe(255);
+    });
+
+    it('normalizes fractional alpha in range (0, 1] to 0-255', () => {
+      const color = Color.fromRGBA(0, 0, 0, 1.0);
+      expect(color.alpha).toBe(255);
+    });
+
+    it('uses full alpha by default', () => {
+      const color = Color.fromRGBA(10, 20, 30);
+      expect(color.alpha).toBe(255);
+    });
+  });
+
+  describe('component accessors return valid numbers', () => {
+    it('red is not NaN', () => {
+      expect(Color.fromHex('#AABBCCDD').red).not.toBeNaN();
+    });
+
+    it('green is not NaN', () => {
+      expect(Color.fromHex('#AABBCCDD').green).not.toBeNaN();
+    });
+
+    it('blue is not NaN', () => {
+      expect(Color.fromHex('#AABBCCDD').blue).not.toBeNaN();
+    });
+
+    it('alpha is not NaN', () => {
+      expect(Color.fromHex('#AABBCCDD').alpha).not.toBeNaN();
+    });
+  });
+
+  describe('withAlpha', () => {
+    it('replaces alpha while keeping RGB intact', () => {
+      const color = Color.fromHex('#FF8040FF').withAlpha(0.5);
+      expect(color.red).toBe(0xff);
+      expect(color.green).toBe(0x80);
+      expect(color.blue).toBe(0x40);
+      expect(color.alpha).toBe(Math.round(255 * 0.5));
+    });
+  });
+
+  describe('toJSON', () => {
+    it('serializes with a leading # character', () => {
+      const color = Color.fromHex('#FF8040FF');
+      expect(color.toJSON()).toMatch(/^#/);
+    });
+
+    it('round-trips through fromHex and toJSON', () => {
+      const hex = '#FF8040FF';
+      expect(Color.fromHex(hex).toJSON()).toBe(hex);
+    });
+  });
+});