scandit-datacapture-frameworks-core 8.0.0 → 8.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scandit-datacapture-frameworks-core",
-  "version": "8.0.0",
+  "version": "8.1.0",
   "description": "Core common package",
   "author": {
     "name": "Scandit",
@@ -12,6 +12,7 @@
   "scripts": {
     "build": "rollup -c rollup.config.js --bundleConfigAsCjs",
     "clean": "rimraf .rollup.cache dist",
+    "lint": "eslint ./src",
     "prepack": "pnpm run build",
     "test": "jest --passWithNoTests",
     "coverage": "jest --coverage --passWithNoTests"
@@ -23,4 +24,4 @@
     "eventemitter3"
   ],
   "packageManager": "pnpm@10.15.0"
-}
+}

package/test/ProxyRegistration.test.ts

@@ -0,0 +1,75 @@
+import { registerProxies, NativeCallerProvider } from '../src/proxies/ProxyRegistration';
+import { FactoryMaker } from '../src/FactoryMaker';
+import { NativeCaller } from '../src/proxies/NativeCaller';
+
+describe('ProxyRegistration', () => {
+  beforeEach(() => {
+    FactoryMaker.instances.clear();
+  });
+
+  it('should register all provided proxy types', () => {
+    const mockCaller: NativeCaller = {
+      callFn: jest.fn(),
+      registerEvent: jest.fn(),
+      unregisterEvent: jest.fn(),
+      eventHook: jest.fn()
+    };
+    const mockProvider: NativeCallerProvider = {
+      getNativeCaller: jest.fn(() => mockCaller)
+    };
+
+    const proxyTypes = ['ProxyA', 'ProxyB', 'ProxyC'];
+    registerProxies(proxyTypes, mockProvider);
+
+    proxyTypes.forEach(proxyType => {
+      expect(FactoryMaker.instances.has(proxyType)).toBe(true);
+    });
+  });
+
+  it('should call provider.getNativeCaller for each proxy type when instantiated', () => {
+    const mockCaller: NativeCaller = {
+      callFn: jest.fn(),
+      registerEvent: jest.fn(),
+      unregisterEvent: jest.fn(),
+      eventHook: jest.fn()
+    };
+    const mockProvider: NativeCallerProvider = {
+      getNativeCaller: jest.fn(() => mockCaller)
+    };
+
+    const proxyTypes = ['ProxyA', 'ProxyB'];
+    registerProxies(proxyTypes, mockProvider);
+
+    // Force lazy instantiation
+    proxyTypes.forEach(proxyType => {
+      FactoryMaker.getInstance(proxyType);
+    });
+
+    expect(mockProvider.getNativeCaller).toHaveBeenCalledTimes(2);
+    expect(mockProvider.getNativeCaller).toHaveBeenCalledWith('ProxyA');
+    expect(mockProvider.getNativeCaller).toHaveBeenCalledWith('ProxyB');
+  });
+
+  it('should create new proxy instances for each call to createInstance', () => {
+    const mockCaller: NativeCaller = {
+      callFn: jest.fn(),
+      registerEvent: jest.fn(),
+      unregisterEvent: jest.fn(),
+      eventHook: jest.fn()
+    };
+    const mockProvider: NativeCallerProvider = {
+      getNativeCaller: jest.fn(() => mockCaller)
+    };
+
+    registerProxies(['ProxyA'], mockProvider);
+
+    const instance1 = FactoryMaker.createInstance('ProxyA');
+    const instance2 = FactoryMaker.createInstance('ProxyA');
+
+    expect(instance1).toBeDefined();
+    expect(instance2).toBeDefined();
+    expect(instance1).not.toBe(instance2);
+    expect(mockProvider.getNativeCaller).toHaveBeenCalledTimes(2);
+  });
+});
+

package/dist/dts/BaseController.d.ts

@@ -1,50 +0,0 @@
-import { EventEmitter } from "./EventEmitter";
-import { NativeCaller, ProxyEvent } from "./proxies";
-export declare class BaseController<PROXY> {
-    protected eventEmitter: EventEmitter;
-    private proxyName;
-    protected get _proxy(): PROXY;
-    constructor(proxyName: string);
-}
-export declare class BaseNativeProxy {
-    protected eventEmitter: EventEmitter;
-    constructor();
-}
-/**
- * AdvancedNativeProxy will provide an easy way to communicate between native proxies
- * and other parts of the architecture such as the controller layer
- */
-export declare class AdvancedNativeProxy extends BaseNativeProxy {
-    protected nativeCaller: NativeCaller;
-    protected events: ProxyEvent[];
-    protected eventSubscriptions: Map<string, any>;
-    [k: string]: any;
-    constructor(nativeCaller: NativeCaller, events?: ProxyEvent[]);
-    dispose(): Promise<void>;
-    _call(fnName: string, args: object | undefined | null): Promise<any>;
-    private _registerEvent;
-    private _unregisterEvent;
-}
-/**
- * Function to create a custom AdvancedNativeProxy. This will return an object which will provide dynamically the
- * methods specified in the PROXY interface.
- *
- * The Proxy interface implemented in order to call native methods will require a special mark
- * `$methodName` for method calls
- * `on$methodName` for the listeners added to the events defined in eventsEnum
- * @param nativeCaller
- * @param eventsEnum
- */
-export declare function createAdvancedNativeProxy<PROXY>(nativeCaller: NativeCaller, eventsEnum?: any): PROXY;
-/**
- * Function to create a custom AdvancedNativeProxy. This will return an object which will provide dynamically the
- * methods specified in the PROXY interface.
- *
- * The Proxy interface implemented in order to call native methods will require a special mark
- * `$methodName` for method calls
- * `on$methodName` for the listeners added to the events defined in eventsEnum
- * @param klass
- * @param nativeCaller
- * @param eventsEnum
- */
-export declare function createAdvancedNativeFromCtorProxy<PROXY>(klass: new (nativeCaller: NativeCaller, events: ProxyEvent[]) => Partial<PROXY>, nativeCaller: NativeCaller, eventsEnum?: any): PROXY;

package/dist/dts/proxies/AdvancedInstanceAwareNativeProxy.d.ts

@@ -1,30 +0,0 @@
-import { BaseInstanceAwareNativeProxy } from "./BaseInstanceAwareNativeProxy";
-import { NativeCaller } from "./NativeCaller";
-import { ProxyEvent } from "./ProxyEvent";
-/**
- * AdvancedNativeProxy will provide an easy way to communicate between native proxies
- * and other parts of the architecture such as the controller layer
- */
-export declare class AdvancedInstanceAwareNativeProxy extends BaseInstanceAwareNativeProxy {
-    protected nativeCaller: NativeCaller;
-    protected events: ProxyEvent[];
-    protected eventSubscriptions: Map<string, any>;
-    private eventHandlers;
-    [k: string]: any;
-    constructor(nativeCaller: NativeCaller, events?: ProxyEvent[]);
-    dispose(): Promise<void>;
-    _call(fnName: string, args: object | undefined | null): Promise<any>;
-    private _registerEvent;
-    private _unregisterEvent;
-}
-/**
- * Function to create a custom AdvancedNativeProxy. This will return an object which will provide dynamically the
- * methods specified in the PROXY interface.
- *
- * The Proxy interface implemented in order to call native methods will require a special mark
- * `$methodName` for method calls
- * `on$methodName` for the listeners added to the events defined in eventsEnum
- * @param nativeCaller
- * @param eventsEnum
- */
-export declare function createAdvancedInstanceAwareNativeProxy<PROXY>(nativeCaller: NativeCaller, eventsEnum?: any): PROXY;

package/dist/dts/proxies/BaseInstanceAwareNativeProxy.d.ts

@@ -1,5 +0,0 @@
-import { EventEmitter } from "../EventEmitter";
-export declare class BaseInstanceAwareNativeProxy {
-    eventEmitter: EventEmitter;
-    constructor();
-}