scandit-datacapture-frameworks-core 8.2.1 → 8.3.0-beta.1

package/dist/dts/ClusteringMode.d.ts

@@ -0,0 +1,6 @@
+export declare enum ClusteringMode {
+    Disabled = "disabled",
+    Manual = "manual",
+    Auto = "auto",
+    AutoWithManualCorrection = "autoWithManualCorrection"
+}

package/dist/dts/camera/Camera.d.ts

@@ -1,5 +1,5 @@
 import { DataCaptureContext } from "../context";
-import { FrameSource, FrameSourceListener, FrameSourceState } from "../frame";
+import { FrameSource, FrameSourceListener, FrameSourceState, TorchListener, MacroModeListener } from "../frame";
 import { DefaultSerializeable } from "../serializable";
 import { CameraController } from "./controller/CameraController";
 import { TorchState } from "./TorchState";
@@ -29,11 +29,15 @@ export declare class Camera extends DefaultSerializeable implements FrameSource
     private controller;
     private type;
     private settings;
-    private position;
+    private _position;
     private _desiredTorchState;
     private _desiredState;
+    private _hasTorchStateListeners;
+    private _hasMacroModeListeners;
     private currentCameraState;
     private listeners;
+    private torchListeners;
+    private macroModeListeners;
     private _context;
     private nativeReadyResolver;
     private nativeReadyRejecter;
@@ -50,12 +54,19 @@ export declare class Camera extends DefaultSerializeable implements FrameSource
     getIsTorchAvailable(): Promise<boolean>;
     addListener(listener: FrameSourceListener | null): void;
     removeListener(listener: FrameSourceListener | null): void;
+    addTorchListener(listener: TorchListener): void;
+    removeTorchListener(listener: TorchListener): void;
+    addMacroModeListener(listener: MacroModeListener): void;
+    removeMacroModeListener(listener: MacroModeListener): void;
     applySettings(settings: CameraSettings): Promise<void>;
     private set context(value);
     private get context();
     private setNativeFrameSourceIsBeingCreated;
     private get isActiveCamera();
     static get default(): Camera | null;
+    static isMacroModeAvailable(): Promise<boolean>;
+    get position(): CameraPosition;
+    get isTorchAvailable(): Promise<boolean>;
     get desiredState(): FrameSourceState;
     set desiredTorchState(desiredTorchState: TorchState);
     get desiredTorchState(): TorchState;
@@ -64,12 +75,14 @@ export declare class Camera extends DefaultSerializeable implements FrameSource
 }
 export interface PrivateCamera {
     context: DataCaptureContext | null;
-    position: CameraPosition;
+    _position: CameraPosition;
     _desiredState: FrameSourceState;
     currentCameraState: FrameSourceState;
     desiredTorchState: TorchState;
     settings: CameraSettings | null;
     listeners: FrameSourceListener[];
+    torchListeners: TorchListener[];
+    macroModeListeners: MacroModeListener[];
     controller: CameraController;
     get isActiveCamera(): boolean;
     initialize: () => void;

package/dist/dts/camera/CameraSettings.d.ts

@@ -2,6 +2,7 @@ import { DefaultSerializeable } from "../serializable";
 import { FocusGestureStrategy } from "./FocusGestureStrategy";
 import { FocusRange } from "./FocusRange";
 import { VideoResolution } from "./VideoResolution";
+import { MacroMode } from "./MacroMode";
 export interface CameraSettingsJSON {
     preferredResolution: string;
     zoomFactor: number;
@@ -20,6 +21,9 @@ export declare class CameraSettings extends DefaultSerializeable {
     preferredResolution: VideoResolution;
     zoomFactor: number;
     zoomGestureZoomFactor: number;
+    torchLevel: number;
+    macroMode: MacroMode;
+    adaptiveExposure: boolean;
     private static get coreDefaults();
     private focusHiddenProperties;
     private focus;

package/dist/dts/camera/FocusGesture.d.ts

@@ -1,2 +1,8 @@
+import { PointWithUnit } from "../common";
+import { FocusGestureListener } from "./FocusGestureListener";
 export interface FocusGesture {
+    showUIIndicator: boolean;
+    addListener(listener: FocusGestureListener): void;
+    removeListener(listener: FocusGestureListener): void;
+    triggerFocus(point: PointWithUnit): Promise<void>;
 }

package/dist/dts/camera/FocusGestureListener.d.ts

@@ -0,0 +1,5 @@
+import { FocusGesture } from "./FocusGesture";
+import { PointWithUnit } from "../common";
+export interface FocusGestureListener {
+    didFocusGesture?(focusGesture: FocusGesture, point: PointWithUnit): void;
+}

package/dist/dts/camera/FocusGestureListenerEvents.d.ts

@@ -0,0 +1,3 @@
+export declare enum FocusGestureListenerEvents {
+    onFocusGesture = "FocusGestureListener.onFocusGesture"
+}

package/dist/dts/camera/MacroMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum MacroMode {
+    Auto = "auto",
+    Off = "off",
+    On = "on"
+}

package/dist/dts/camera/SwipeToZoom.d.ts

@@ -1,6 +1,20 @@
 import { DefaultSerializeable } from "../serializable";
+import { DataCaptureViewController } from "../view";
 import { ZoomGesture } from "./ZoomGesture";
+import { ZoomGestureListener } from "./ZoomGestureListener";
+export interface PrivateSwipeToZoom {
+    listeners: ZoomGestureListener[];
+    onListenersChanged?(): void;
+    _controller?: DataCaptureViewController | null;
+}
 export declare class SwipeToZoom extends DefaultSerializeable implements ZoomGesture {
     private type;
+    private listeners;
+    private onListenersChanged?;
+    private _controller?;
     constructor();
+    addListener(listener: ZoomGestureListener): void;
+    removeListener(listener: ZoomGestureListener): void;
+    triggerZoomIn(): Promise<void>;
+    triggerZoomOut(): Promise<void>;
 }

package/dist/dts/camera/TapToFocus.d.ts

@@ -1,6 +1,21 @@
 import { DefaultSerializeable } from "../serializable";
 import { FocusGesture } from "./FocusGesture";
+import { FocusGestureListener } from "./FocusGestureListener";
+import { PointWithUnit } from "../common";
+import { DataCaptureViewController } from "../view";
+export interface PrivateTapToFocus {
+    listeners: FocusGestureListener[];
+    onListenersChanged?(): void;
+    _controller?: DataCaptureViewController | null;
+}
 export declare class TapToFocus extends DefaultSerializeable implements FocusGesture {
     private type;
+    showUIIndicator: boolean;
+    private listeners;
+    private onListenersChanged?;
+    private _controller?;
     constructor();
+    addListener(listener: FocusGestureListener): void;
+    removeListener(listener: FocusGestureListener): void;
+    triggerFocus(point: PointWithUnit): Promise<void>;
 }

package/dist/dts/camera/TorchSwitchControl.d.ts

@@ -6,6 +6,11 @@ export declare class TorchSwitchControl extends DefaultSerializeable implements
     private view;
     private anchor;
     private offset;
+    accessibilityLabelWhenOff: string | null;
+    accessibilityHintWhenOff: string | null;
+    accessibilityLabelWhenOn: string | null;
+    accessibilityHintWhenOn: string | null;
+    constructor();
     get torchOffImage(): string | null;
     set torchOffImage(torchOffImage: string | null);
     get torchOffPressedImage(): string | null;

package/dist/dts/camera/ZoomGesture.d.ts

@@ -1,4 +1,9 @@
+import { ZoomGestureListener } from "./ZoomGestureListener";
 export interface ZoomGesture {
+    addListener(listener: ZoomGestureListener): void;
+    removeListener(listener: ZoomGestureListener): void;
+    triggerZoomIn(): Promise<void>;
+    triggerZoomOut(): Promise<void>;
 }
 export interface ZoomGestureJSON {
     type: string;

package/dist/dts/camera/ZoomGestureListener.d.ts

@@ -0,0 +1,5 @@
+import { ZoomGesture } from "./ZoomGesture";
+export interface ZoomGestureListener {
+    didZoomInGesture?(zoomGesture: ZoomGesture): void;
+    didZoomOutGesture?(zoomGesture: ZoomGesture): void;
+}

package/dist/dts/camera/ZoomGestureListenerEvents.d.ts

@@ -0,0 +1,4 @@
+export declare enum ZoomGestureListenerEvents {
+    onZoomInGesture = "ZoomGestureListener.onZoomInGesture",
+    onZoomOutGesture = "ZoomGestureListener.onZoomOutGesture"
+}

package/dist/dts/camera/ZoomSwitchControl.d.ts

@@ -6,6 +6,13 @@ export declare class ZoomSwitchControl extends DefaultSerializeable implements C
     private view;
     private anchor;
     private offset;
+    contentDescriptionWhenZoomedOut: string | null;
+    contentDescriptionWhenZoomedIn: string | null;
+    accessibilityLabelWhenZoomedOut: string | null;
+    accessibilityLabelWhenZoomedIn: string | null;
+    accessibilityHintWhenZoomedOut: string | null;
+    accessibilityHintWhenZoomedIn: string | null;
+    constructor();
     get zoomedOutImage(): string | null;
     set zoomedOutImage(zoomedOutImage: string | null);
     get zoomedInImage(): string | null;

package/dist/dts/camera/controller/CameraController.d.ts

@@ -12,7 +12,15 @@ export declare class CameraController extends BaseController<CoreProxy> {
     switchCameraToDesiredState(desiredState: FrameSourceState): Promise<void>;
     subscribeListener(): Promise<void>;
     unsubscribeListener(): Promise<void>;
+    subscribeTorchListener(): Promise<void>;
+    unsubscribeTorchListener(): Promise<void>;
+    subscribeMacroModeListener(): Promise<void>;
+    unsubscribeMacroModeListener(): Promise<void>;
     dispose(): void;
     private handleDidChangeStateEvent;
     private handleDidChangeStateEventWrapper;
+    private handleDidChangeTorchToStateEvent;
+    private handleDidChangeTorchToStateEventWrapper;
+    private handleDidChangeMacroModeEvent;
+    private handleDidChangeMacroModeEventWrapper;
 }

package/dist/dts/camera/index.d.ts

@@ -1,7 +1,11 @@
 export * from "./FocusGesture";
+export * from "./FocusGestureListener";
+export * from "./FocusGestureListenerEvents";
 export * from "./TapToFocus";
 export * from "./PrivateFocusGestureDeserializer";
 export * from "./ZoomGesture";
+export * from "./ZoomGestureListener";
+export * from "./ZoomGestureListenerEvents";
 export * from "./controller/CameraController";
 export * from "./controller/FrameDataController";
 export * from "./Camera";
@@ -14,3 +18,4 @@ export * from "./FocusGestureStrategy";
 export * from "./LogoStyle";
 export * from "./SwipeToZoom";
 export * from "./CameraSettings";
+export * from "./MacroMode";

package/dist/dts/camerahelpers/MacroModeListenerEvents.d.ts

@@ -0,0 +1,3 @@
+export declare enum MacroModeListenerEvents {
+    didChangeMacroMode = "MacroModeListener.onMacroModeChanged"
+}

package/dist/dts/camerahelpers/TorchListenerEvents.d.ts

@@ -0,0 +1,3 @@
+export declare enum TorchListenerEvents {
+    didChangeTorchToState = "TorchListener.onTorchStateChanged"
+}

package/dist/dts/camerahelpers/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./CameraPosition";
 export * from "./FrameSourceListenerEvents";
+export * from "./TorchListenerEvents";
+export * from "./MacroModeListenerEvents";
 export * from "./CameraOwner";
 export * from "./CameraOwnershipManager";
 export * from "./CameraOwnershipHelper";

package/dist/dts/common/Payload.d.ts

@@ -15,9 +15,44 @@ export interface DidChangeStateEventPayload {
 export interface EventPayload {
     name: string;
     data: string;
+    viewId?: number;
+    modeId?: number;
 }
+/**
+ * Symbol returned by parseIfShouldHandle when an event should be skipped
+ * (filtered out based on viewId/modeId mismatch).
+ */
+export declare const SKIP: unique symbol;
 export declare class EventDataParser {
-    static parse<T>(data: string): T | null;
+    private static parse;
+    /**
+     * Check if an event should be handled based on viewId/modeId filtering.
+     * Used by React Native new architecture for pre-parse filtering to avoid
+     * unnecessary JSON parsing of events not intended for this consumer.
+     *
+     * @param ev The event payload to check
+     * @param ids Object containing optional viewId and/or modeId to match against
+     * @returns true if the event should be handled, false if it should be skipped
+     */
+    static shouldHandle(ev: EventPayload, ids: {
+        viewId?: number;
+        modeId?: number;
+    }): boolean;
+    /**
+     * Parse event data if it should be handled, otherwise return SKIP.
+     *
+     * Filtering is performed in two stages:
+     * 1. Pre-parse: if the event wrapper carries viewId/modeId, skip parsing entirely on mismatch.
+     * 2. Post-parse: verify the parsed payload's viewId/modeId matches the expected ids.
+     *
+     * @param ev The event payload to check and parse
+     * @param ids Object containing optional viewId and/or modeId to match against
+     * @returns SKIP if filtered out, null if parse failed, or parsed data
+     */
+    static parseIfShouldHandle<T>(ev: EventPayload, ids: {
+        viewId?: number;
+        modeId?: number;
+    }): T | null | typeof SKIP;
 }
 export interface NativeCallResult {
     data: string;

package/dist/dts/defaults/CoreDefaults.d.ts

@@ -1,4 +1,4 @@
-import { FocusGesture, FocusGestureStrategy, FocusRange, LogoStyle, VideoResolution, ZoomGesture } from "../camera";
+import { FocusGesture, FocusGestureStrategy, FocusRange, LogoStyle, MacroMode, VideoResolution, ZoomGesture } from "../camera";
 import { CameraPosition } from "../camerahelpers";
 import { Anchor, Brush, Color, MarginsWithUnit, NumberWithUnit, PointWithUnit, SizeWithUnitAndAspect } from "../common";
 import { RectangularViewfinderAnimation, RectangularViewfinderLineStyle, RectangularViewfinderStyle } from "../viewfinder";
@@ -9,6 +9,9 @@ export interface CameraSettingsDefaults {
     zoomGestureZoomFactor: number;
     focusGestureStrategy: FocusGestureStrategy;
     shouldPreferSmoothAutoFocus: boolean;
+    torchLevel: number;
+    macroMode: MacroMode;
+    adaptiveExposure: boolean;
     properties: {
         [key: string]: unknown;
     };
@@ -27,6 +30,7 @@ export interface CoreDefaults {
         focusGesture: FocusGesture | null;
         zoomGesture: ZoomGesture | null;
         logoStyle: LogoStyle;
+        shouldShowZoomNotification?: boolean;
     };
     RectangularViewfinder: {
         defaultStyle: string;

package/dist/dts/defaults/getCoreDefaults.d.ts

@@ -1,2 +1,2 @@
-import { CoreDefaults } from "./CoreDefaults";
+import { CoreDefaults } from './CoreDefaults';
 export declare function getCoreDefaults(): CoreDefaults;

package/dist/dts/frame/FrameData.d.ts

@@ -1,17 +1,23 @@
 import { ImageBuffer, ImageBufferJSON } from "./ImageBuffer";
 export interface FrameData {
     readonly imageBuffers: ImageBuffer[];
+    readonly imageBuffer: ImageBuffer;
     readonly orientation: number;
+    readonly timestamp: number;
 }
 export interface FrameDataJSON {
     imageBuffers: ImageBufferJSON[];
     orientation: number;
+    timestamp?: number;
 }
 export declare class PrivateFrameData implements FrameData {
     private _imageBuffers;
     private _orientation;
+    private _timestamp;
     get imageBuffers(): ImageBuffer[];
+    get imageBuffer(): ImageBuffer;
     get orientation(): number;
+    get timestamp(): number;
     static fromJSON(json: FrameDataJSON): FrameData;
     static empty(): FrameData;
 }

package/dist/dts/frame/MacroModeListener.d.ts

@@ -0,0 +1,4 @@
+import { MacroMode } from "../camera/MacroMode";
+export interface MacroModeListener {
+    didChangeMacroMode?(macroMode: MacroMode): void;
+}

package/dist/dts/frame/TorchListener.d.ts

@@ -0,0 +1,4 @@
+import { TorchState } from "../camera/TorchState";
+export interface TorchListener {
+    didChangeTorchToState?(state: TorchState): void;
+}

package/dist/dts/frame/index.d.ts

@@ -1,5 +1,7 @@
 export { FrameSource } from "./FrameSource";
 export { FrameSourceListener } from "./FrameSourceListener";
+export { TorchListener } from "./TorchListener";
+export { MacroModeListener } from "./MacroModeListener";
 export { FrameSourceState } from "./FrameSourceState";
 export { FrameData } from "./FrameData";
 export { ImageBuffer } from "./ImageBuffer";

package/dist/dts/generated/CoreProxyAdapter.d.ts

@@ -29,6 +29,10 @@ export declare class CoreProxyAdapter {
     isTorchAvailable({ cameraPosition }: {
         cameraPosition: string;
     }): Promise<boolean>;
+    /**
+     * Checks if macro mode is available for the current device
+     */
+    isMacroModeAvailable(): Promise<boolean>;
     /**
      * Registers a persistent listener for frame source state change events
      */
@@ -37,6 +41,22 @@ export declare class CoreProxyAdapter {
      * Unregisters the frame source event listener
      */
     unregisterFrameSourceListener(): Promise<void>;
+    /**
+     * Registers a persistent listener for torch state change events
+     */
+    registerTorchStateListener(): Promise<void>;
+    /**
+     * Unregisters the torch state event listener
+     */
+    unregisterTorchStateListener(): Promise<void>;
+    /**
+     * Registers a persistent listener for macro mode change events
+     */
+    registerMacroModeListener(): Promise<void>;
+    /**
+     * Unregisters the macro mode event listener
+     */
+    unregisterMacroModeListener(): Promise<void>;
     /**
      * Gets the last frame data by frame ID as JSON
      * @param frameId Unique frame identifier
@@ -131,6 +151,57 @@ export declare class CoreProxyAdapter {
     unregisterListenerForViewEvents({ viewId }: {
         viewId: number;
     }): Promise<void>;
+    /**
+     * Registers a persistent listener for focus gesture events
+     * @param viewId View identifier
+     */
+    registerFocusGestureListener({ viewId }: {
+        viewId: number;
+    }): Promise<void>;
+    /**
+     * Unregisters the focus gesture event listener
+     * @param viewId View identifier
+     */
+    unregisterFocusGestureListener({ viewId }: {
+        viewId: number;
+    }): Promise<void>;
+    /**
+     * Triggers a focus as if the focus gesture was performed
+     * @param viewId View identifier
+     * @param pointJson Point in view coordinates as JSON string
+     */
+    triggerFocus({ viewId, pointJson }: {
+        viewId: number;
+        pointJson: string;
+    }): Promise<void>;
+    /**
+     * Triggers a zoom in gesture as if the zoom gesture was performed
+     * @param viewId View identifier
+     */
+    triggerZoomIn({ viewId }: {
+        viewId: number;
+    }): Promise<void>;
+    /**
+     * Triggers a zoom out gesture as if the zoom gesture was performed
+     * @param viewId View identifier
+     */
+    triggerZoomOut({ viewId }: {
+        viewId: number;
+    }): Promise<void>;
+    /**
+     * Registers a persistent listener for zoom gesture events
+     * @param viewId View identifier
+     */
+    registerZoomGestureListener({ viewId }: {
+        viewId: number;
+    }): Promise<void>;
+    /**
+     * Unregisters the zoom gesture event listener
+     * @param viewId View identifier
+     */
+    unregisterZoomGestureListener({ viewId }: {
+        viewId: number;
+    }): Promise<void>;
     /**
      * Updates the DataCaptureView configuration
      * @param viewJson Updated view configuration as JSON string

package/dist/dts/index.d.ts

@@ -19,4 +19,5 @@ export { FactoryMaker } from "./FactoryMaker";
 export * from "./proxy-types";
 export * from "./proxy-registration";
 export * from "./helpers";
+export * from "./ClusteringMode";
 export * from "./generated";

package/dist/dts/view/DataCaptureView.d.ts

@@ -42,6 +42,9 @@ export declare class BaseDataCaptureView extends DefaultSerializeable {
     private _logoStyle;
     get logoStyle(): LogoStyle;
     set logoStyle(newValue: LogoStyle);
+    private _shouldShowZoomNotification;
+    get shouldShowZoomNotification(): boolean;
+    set shouldShowZoomNotification(newValue: boolean);
     private controls;
     private controller;
     private isViewCreated;
@@ -55,6 +58,9 @@ export declare class BaseDataCaptureView extends DefaultSerializeable {
     removeListener(listener: DataCaptureViewListener): void;
     viewPointForFramePoint(point: Point): Promise<Point>;
     viewQuadrilateralForFrameQuadrilateral(quadrilateral: Quadrilateral): Promise<Quadrilateral>;
+    triggerFocus(point: PointWithUnit): Promise<void>;
+    triggerZoomIn(): Promise<void>;
+    triggerZoomOut(): Promise<void>;
     addControl(control: Control): Promise<void>;
     addControlWithAnchorAndOffset(control: Control, anchor: Anchor, offset: PointWithUnit): void;
     removeControl(control: Control): void;
@@ -67,4 +73,5 @@ export declare class BaseDataCaptureView extends DefaultSerializeable {
     setPositionAndSize(top: number, left: number, width: number, height: number, shouldBeUnderWebView: boolean): Promise<void>;
     show(): Promise<void>;
     hide(): Promise<void>;
+    setProperty<T>(name: string, value: T): void;
 }

package/dist/dts/view/DataCaptureViewController.d.ts

@@ -1,7 +1,9 @@
-import { Point, Quadrilateral } from "../common";
+import { Point, Quadrilateral, PointWithUnit } from "../common";
 import { BaseDataCaptureView } from "./DataCaptureView";
 import { BaseController } from "../controllers/BaseController";
 import { CoreProxy } from "../generated";
+import { FocusGesture } from "../camera";
+import { ZoomGesture } from "../camera";
 export interface DataCaptureViewProxy extends CoreProxy {
     $showDataCaptureView({ viewId }: {
         viewId: number;
@@ -24,15 +26,21 @@ export interface DataCaptureViewProxy extends CoreProxy {
     }): Promise<void>;
 }
 export declare enum DataCaptureViewEvents {
-    didChangeSize = "DataCaptureViewListener.onSizeChanged"
+    didChangeSize = "DataCaptureViewListener.onSizeChanged",
+    onFocusGesture = "FocusGestureListener.onFocusGesture"
 }
 export declare class DataCaptureViewController extends BaseController<DataCaptureViewProxy> {
     private view;
     private _listenerRegistered;
+    private _focusGestureListenerRegistered;
+    private _zoomGestureListenerRegistered;
     private adapter;
     constructor(view: BaseDataCaptureView);
     viewPointForFramePoint(point: Point): Promise<Point>;
     viewQuadrilateralForFrameQuadrilateral(quadrilateral: Quadrilateral): Promise<Quadrilateral>;
+    triggerFocus(point: PointWithUnit): Promise<void>;
+    triggerZoomIn(): Promise<void>;
+    triggerZoomOut(): Promise<void>;
     setPositionAndSize(top: number, left: number, width: number, height: number, shouldBeUnderWebView: boolean): Promise<void>;
     show(): Promise<void>;
     hide(): Promise<void>;
@@ -42,6 +50,18 @@ export declare class DataCaptureViewController extends BaseController<DataCaptur
     dispose(): void;
     subscribeListener(): Promise<void>;
     unsubscribeListener(): Promise<void>;
+    updateFocusGestureListenerSubscription(focusGesture: FocusGesture | null, shouldSubscribe: boolean): Promise<void>;
+    private subscribeFocusGestureListener;
+    private unsubscribeFocusGestureListener;
+    private handleOnFocusGestureEvent;
+    private handleOnFocusGestureEventWrapper;
+    updateZoomGestureListenerSubscription(zoomGesture: ZoomGesture | null, shouldSubscribe: boolean): Promise<void>;
+    private subscribeZoomGestureListener;
+    private unsubscribeZoomGestureListener;
+    private handleOnZoomInGestureEvent;
+    private handleOnZoomInGestureEventWrapper;
+    private handleOnZoomOutGestureEvent;
+    private handleOnZoomOutGestureEventWrapper;
     private createView;
     private handleDidChangeSizeEvent;
     private handleDidChangeSizeEventWrapper;