scandit-capacitor-datacapture-parser 6.11.0 → 6.12.0

package/ScanditCapacitorDatacaptureParser.podspec

@@ -16,5 +16,5 @@ Pod::Spec.new do |s|
   s.dependency 'ScanditCapacitorDatacaptureCore'
   s.swift_version = '5.1'
 
-  s.dependency 'ScanditParser', '= 6.11.0'
+  s.dependency 'ScanditParser', '= 6.12.0'
 end

package/android/build.gradle

@@ -5,15 +5,16 @@ ext {
 
 buildscript {
     ext {
-        sdk_version = "6.11.0"
-        kotlin_version = '1.4.21'
+        sdk_version = "6.12.0"
+        kotlin_version = "1.5.31"
+        agp_version = "7.0.3"
     }
     repositories {
         google()
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.0.3'
+        classpath "com.android.tools.build:gradle:$agp_version"
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }

package/dist/esm/scandit-capacitor-datacapture-parser/src/definitions.d.ts

@@ -1,3 +1,695 @@
+export declare type Optional<T> = T | null;
 export interface ScanditParserPluginInterface {
     initialize(): Promise<any>;
 }
+declare module Scandit {
+ 
+export class ParserProxy {
+    private static capacitorExec;
+    private parser;
+    static forParser(parser: Parser): ParserProxy;
+    parseString(data: string): Promise<ParsedData>;
+    parseRawData(data: string): Promise<ParsedData>;
+}
+
+ type ParsedDataJSON = [ParsedFieldJSON];
+interface PrivateParsedData {
+    fromJSON(json: ParsedDataJSON): ParsedData;
+}
+export class ParsedData {
+    private _jsonString;
+    get jsonString(): string;
+    private _fields;
+    get fields(): ParsedField[];
+    private _fieldsByName;
+    get fieldsByName(): {
+        [key: string]: ParsedField;
+    };
+    private static fromJSON;
+}
+
+export interface ParsedFieldJSON {
+    name: string;
+    parsed: any;
+    rawString: string;
+    issues?: string[];
+}
+interface PrivateParsedField {
+    fromJSON(json: ParsedFieldJSON): ParsedField;
+}
+export class ParsedField {
+    private _name;
+    get name(): string;
+    private _parsed;
+    get parsed(): any;
+    private _rawString;
+    get rawString(): string;
+    private _issues;
+    get issues(): string[];
+    private static fromJSON;
+}
+
+
+interface PrivateParser extends PrivateDataCaptureComponent {
+    dataFormat: ParserDataFormat;
+    options: {
+        [key: string]: any;
+    };
+    proxy: ParserProxy;
+    isInitialized: boolean;
+    waitingForInitialization: [() => void];
+    waitForInitialization: Promise<void>;
+}
+export class Parser implements DataCaptureComponent {
+    private type;
+    private dataFormat;
+    private options;
+    private _id;
+    get id(): string;
+    private _context;
+    private isInitialized;
+    private waitingForInitialization;
+    private _proxy;
+    private get proxy();
+    static forContextAndFormat(context: DataCaptureContext, dataFormat: ParserDataFormat): Promise<Parser>;
+    private constructor();
+    setOptions(options: {
+        [key: string]: any;
+    }): Promise<void>;
+    parseString(data: string): Promise<ParsedData>;
+    parseRawData(data: string): Promise<ParsedData>;
+    private waitForInitialization;
+}
+
+export enum ParserDataFormat {
+    GS1AI = "gs1ai",
+    HIBC = "hibc",
+    DLID = "dlid",
+    MRTD = "mrtd",
+    SwissQR = "swissQr",
+    VIN = "vin",
+    UsUsid = "usUsid"
+}
+
+
+export enum FrameSourceState {
+    On = "on",
+    Off = "off",
+    Starting = "starting",
+    Stopping = "stopping",
+    Standby = "standby",
+    BootingUp = "bootingUp",
+    WakingUp = "wakingUp",
+    GoingToSleep = "goingToSleep",
+    ShuttingDown = "shuttingDown"
+}
+export enum TorchState {
+    On = "on",
+    Off = "off",
+    Auto = "auto"
+}
+export enum CameraPosition {
+    WorldFacing = "worldFacing",
+    UserFacing = "userFacing",
+    Unspecified = "unspecified"
+}
+export enum VideoResolution {
+    Auto = "auto",
+    HD = "hd",
+    FullHD = "fullHd",
+    UHD4K = "uhd4k"
+}
+export enum FocusRange {
+    Full = "full",
+    Near = "near",
+    Far = "far"
+}
+export enum FocusGestureStrategy {
+    None = "none",
+    Manual = "manual",
+    ManualUntilCapture = "manualUntilCapture",
+    AutoOnLocation = "autoOnLocation"
+}
+export interface FrameSourceListener {
+    didChangeState?(frameSource: FrameSource, newState: FrameSourceState): void;
+}
+export interface FrameSource {
+    readonly desiredState: FrameSourceState;
+    switchToDesiredState(desiredState: FrameSourceState): Promise<void>;
+    getCurrentState(): Promise<FrameSourceState>;
+    addListener(listener: FrameSourceListener): void;
+    removeListener(listener: FrameSourceListener): void;
+}
+export interface CameraSettingsJSON {
+    preferredResolution: string;
+    zoomFactor: number;
+    focusRange: string;
+    zoomGestureZoomFactor: number;
+    focusGestureStrategy: string;
+    shouldPreferSmoothAutoFocus: boolean;
+    api: number;
+}
+interface PrivateCameraSettings {
+    fromJSON(json: CameraSettingsJSON): CameraSettings;
+}
+export class CameraSettings {
+    preferredResolution: VideoResolution;
+    zoomFactor: number;
+    zoomGestureZoomFactor: number;
+    private api;
+    private focus;
+    get focusRange(): FocusRange;
+    set focusRange(newRange: FocusRange);
+    get focusGestureStrategy(): FocusGestureStrategy;
+    set focusGestureStrategy(newStrategy: FocusGestureStrategy);
+    get shouldPreferSmoothAutoFocus(): boolean;
+    set shouldPreferSmoothAutoFocus(newShouldPreferSmoothAutoFocus: boolean);
+    private static fromJSON;
+    constructor();
+    constructor(settings: CameraSettings);
+    setProperty(name: string, value: any): void;
+    getProperty(name: string): any;
+}
+
+ 
+export class DataCaptureContextProxy {
+    private context;
+    static forDataCaptureContext(context: DataCaptureContext): DataCaptureContextProxy;
+    updateContextFromJSON(): Promise<void>;
+    dispose(): void;
+    private initialize;
+    private initializeContextFromJSON;
+    private subscribeListener;
+    private notifyListeners;
+}
+
+
+export class DataCaptureViewProxy {
+    private view;
+    static forDataCaptureView(view: DataCaptureView): DataCaptureViewProxy;
+    setPositionAndSize(top: number, left: number, width: number, height: number, shouldBeUnderWebView: boolean): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    viewPointForFramePoint(point: Point): Promise<Point>;
+    viewQuadrilateralForFrameQuadrilateral(quadrilateral: Quadrilateral): Promise<Quadrilateral>;
+    private subscribeListener;
+    private notifyListeners;
+    private initialize;
+}
+
+
+export interface PointJSON {
+    x: number;
+    y: number;
+}
+interface PrivatePoint {
+    fromJSON(json: PointJSON): Point;
+}
+export class Point {
+    private _x;
+    private _y;
+    get x(): number;
+    get y(): number;
+    private static fromJSON;
+    constructor(x: number, y: number);
+}
+export interface QuadrilateralJSON {
+    topLeft: PointJSON;
+    topRight: PointJSON;
+    bottomRight: PointJSON;
+    bottomLeft: PointJSON;
+}
+interface PrivateQuadrilateral {
+    fromJSON(json: QuadrilateralJSON): Quadrilateral;
+}
+export class Quadrilateral {
+    private _topLeft;
+    private _topRight;
+    private _bottomRight;
+    private _bottomLeft;
+    get topLeft(): Point;
+    get topRight(): Point;
+    get bottomRight(): Point;
+    get bottomLeft(): Point;
+    private static fromJSON;
+    constructor(topLeft: Point, topRight: Point, bottomRight: Point, bottomLeft: Point);
+}
+export enum MeasureUnit {
+    DIP = "dip",
+    Pixel = "pixel",
+    Fraction = "fraction"
+}
+export interface NumberWithUnitJSON {
+    value: number;
+    unit: string;
+}
+interface PrivateNumberWithUnit {
+    fromJSON(json: NumberWithUnitJSON): NumberWithUnit;
+}
+export class NumberWithUnit {
+    private _value;
+    private _unit;
+    get value(): number;
+    get unit(): MeasureUnit;
+    private static fromJSON;
+    constructor(value: number, unit: MeasureUnit);
+}
+export interface PointWithUnitJSON {
+    x: NumberWithUnitJSON;
+    y: NumberWithUnitJSON;
+}
+interface PrivatePointWithUnit {
+    readonly zero: PointWithUnit;
+    fromJSON(json: PointWithUnitJSON): PointWithUnit;
+}
+export class PointWithUnit {
+    private _x;
+    private _y;
+    get x(): NumberWithUnit;
+    get y(): NumberWithUnit;
+    private static fromJSON;
+    private static get zero();
+    constructor(x: NumberWithUnit, y: NumberWithUnit);
+}
+export class Rect {
+    private _origin;
+    private _size;
+    get origin(): Point;
+    get size(): Size;
+    constructor(origin: Point, size: Size);
+}
+export class RectWithUnit {
+    private _origin;
+    private _size;
+    get origin(): PointWithUnit;
+    get size(): SizeWithUnit;
+    constructor(origin: PointWithUnit, size: SizeWithUnit);
+}
+export class SizeWithUnit {
+    private _width;
+    private _height;
+    get width(): NumberWithUnit;
+    get height(): NumberWithUnit;
+    constructor(width: NumberWithUnit, height: NumberWithUnit);
+}
+export interface SizeJSON {
+    width: number;
+    height: number;
+}
+export class Size {
+    private _width;
+    private _height;
+    get width(): number;
+    get height(): number;
+    private static fromJSON;
+    constructor(width: number, height: number);
+}
+export class SizeWithAspect {
+    private _size;
+    private _aspect;
+    get size(): NumberWithUnit;
+    get aspect(): number;
+    constructor(size: NumberWithUnit, aspect: number);
+}
+export enum SizingMode {
+    WidthAndHeight = "widthAndHeight",
+    WidthAndAspectRatio = "widthAndAspectRatio",
+    HeightAndAspectRatio = "heightAndAspectRatio",
+    ShorterDimensionAndAspectRatio = "shorterDimensionAndAspectRatio"
+}
+export interface SizeWithUnitAndAspectJSON {
+    width?: NumberWithUnitJSON;
+    height?: NumberWithUnitJSON;
+    shorterDimension?: NumberWithUnitJSON;
+    aspect?: number;
+}
+interface PrivateSizeWithUnitAndAspect {
+    fromJSON(json: SizeWithUnitAndAspectJSON): SizeWithUnitAndAspect;
+}
+export class SizeWithUnitAndAspect {
+    private _widthAndHeight;
+    private _widthAndAspectRatio;
+    private _heightAndAspectRatio;
+    private _shorterDimensionAndAspectRatio;
+    get widthAndHeight(): Optional<SizeWithUnit>;
+    get widthAndAspectRatio(): Optional<SizeWithAspect>;
+    get heightAndAspectRatio(): Optional<SizeWithAspect>;
+    get shorterDimensionAndAspectRatio(): SizeWithAspect | null;
+    get sizingMode(): SizingMode;
+    private static sizeWithWidthAndHeight;
+    private static sizeWithWidthAndAspectRatio;
+    private static sizeWithHeightAndAspectRatio;
+    private static sizeWithShorterDimensionAndAspectRatio;
+    private static fromJSON;
+    toJSON(): object;
+}
+export interface MarginsWithUnitJSON {
+    left: NumberWithUnitJSON;
+    right: NumberWithUnitJSON;
+    top: NumberWithUnitJSON;
+    bottom: NumberWithUnitJSON;
+}
+interface PrivateMarginsWithUnit {
+    readonly zero: MarginsWithUnit;
+    fromJSON(json: MarginsWithUnitJSON): MarginsWithUnit;
+}
+export class MarginsWithUnit {
+    private _left;
+    private _right;
+    private _top;
+    private _bottom;
+    get left(): NumberWithUnit;
+    get right(): NumberWithUnit;
+    get top(): NumberWithUnit;
+    get bottom(): NumberWithUnit;
+    private static fromJSON;
+    private static get zero();
+    constructor(left: NumberWithUnit, right: NumberWithUnit, top: NumberWithUnit, bottom: NumberWithUnit);
+} type ColorJSON = string;
+interface PrivateColor {
+    fromJSON(json: ColorJSON): Color;
+}
+export class Color {
+    private hexadecimalString;
+    get redComponent(): string;
+    get greenComponent(): string;
+    get blueComponent(): string;
+    get alphaComponent(): string;
+    get red(): number;
+    get green(): number;
+    get blue(): number;
+    get alpha(): number;
+    static fromHex(hex: string): Color;
+    static fromRGBA(red: number, green: number, blue: number, alpha?: number): Color;
+    private static hexToNumber;
+    private static fromJSON;
+    private static numberToHex;
+    private static normalizeHex;
+    private static normalizeAlpha;
+    private constructor();
+    withAlpha(alpha: number): Color;
+    toJSON(): string;
+}
+export enum Orientation {
+    Unknown = "unknown",
+    Portrait = "portrait",
+    PortraitUpsideDown = "portraitUpsideDown",
+    LandscapeRight = "landscapeRight",
+    LandscapeLeft = "landscapeLeft"
+}
+export enum Direction {
+    None = "none",
+    Horizontal = "horizontal",
+    LeftToRight = "leftToRight",
+    RightToLeft = "rightToLeft",
+    Vertical = "vertical",
+    TopToBottom = "topToBottom",
+    BottomToTop = "bottomToTop"
+}
+
+
+export interface DataCaptureContextListener {
+    didChangeStatus?(context: DataCaptureContext, contextStatus: ContextStatus): void;
+    didStartObservingContext?(context: DataCaptureContext): void;
+}
+interface ContextStatusJSON {
+    code: number;
+    isValid: boolean;
+    message: string;
+}
+interface PrivateContextStatus {
+    fromJSON(json: ContextStatusJSON): ContextStatus;
+}
+export class ContextStatus {
+    private _message;
+    private _code;
+    private _isValid;
+    private static fromJSON;
+    get message(): string;
+    get code(): number;
+    get isValid(): boolean;
+}
+
+
+interface PrivateDataCaptureMode {
+    _context: Optional<DataCaptureContext>;
+}
+export interface DataCaptureMode {
+    isEnabled: boolean;
+    readonly context: Optional<DataCaptureContext>;
+}
+interface PrivateDataCaptureComponent {
+    _context: DataCaptureContext;
+}
+export interface DataCaptureComponent {
+    readonly id: string;
+}
+interface PrivateDataCaptureContext {
+    proxy: DataCaptureContextProxy;
+    modes: [DataCaptureMode];
+    components: [DataCaptureComponent];
+    initialize: () => void;
+    update: () => Promise<void>;
+    addComponent: (component: DataCaptureComponent) => Promise<void>;
+}
+export interface DataCaptureContextCreationOptions {
+    deviceName?: Optional<string>;
+}
+export class DataCaptureContextSettings {
+    constructor();
+    setProperty(name: string, value: any): void;
+    getProperty(name: string): any;
+}
+export class DataCaptureContext {
+    private licenseKey;
+    private deviceName;
+    private framework;
+    private frameworkVersion;
+    private settings;
+    private _frameSource;
+    private view;
+    private modes;
+    private components;
+    private proxy;
+    private listeners;
+    get frameSource(): Optional<FrameSource>;
+    static get deviceID(): Optional<string>;
+    static forLicenseKey(licenseKey: string): DataCaptureContext;
+    static forLicenseKeyWithSettings(licenseKey: string, settings: DataCaptureContextSettings | null): DataCaptureContext;
+    static forLicenseKeyWithOptions(licenseKey: string, options: Optional<DataCaptureContextCreationOptions>): DataCaptureContext;
+    private constructor();
+    setFrameSource(frameSource: Optional<FrameSource>): Promise<void>;
+    addListener(listener: DataCaptureContextListener): void;
+    removeListener(listener: DataCaptureContextListener): void;
+    addMode(mode: DataCaptureMode): void;
+    removeMode(mode: DataCaptureMode): void;
+    removeAllModes(): void;
+    dispose(): void;
+    applySettings(settings: DataCaptureContextSettings): Promise<void>;
+    private initialize;
+    private update;
+    private addComponent;
+}
+
+
+export interface FocusGesture {
+}
+export interface FocusGestureJSON {
+    type: string;
+}
+class PrivateFocusGestureDeserializer {
+    static fromJSON(json: FocusGestureJSON | null): FocusGesture | null;
+}
+export class TapToFocus implements FocusGesture {
+    private type;
+    constructor();
+}
+export interface ZoomGesture {
+}
+export interface ZoomGestureJSON {
+    type: string;
+}
+class PrivateZoomGestureDeserializer {
+    static fromJSON(json: ZoomGestureJSON | null): ZoomGesture | null;
+}
+export class SwipeToZoom implements ZoomGesture {
+    private type;
+    constructor();
+}
+export enum LogoStyle {
+    Minimal = "minimal",
+    Extended = "extended"
+}
+
+
+export interface DataCaptureOverlay {
+}
+export interface Control {
+}
+export class TorchSwitchControl implements Control {
+    private type;
+    private icon;
+    private view;
+    get torchOffImage(): string | null;
+    set torchOffImage(torchOffImage: string | null);
+    get torchOffPressedImage(): string | null;
+    set torchOffPressedImage(torchOffPressedImage: string | null);
+    get torchOnImage(): string | null;
+    set torchOnImage(torchOnImage: string | null);
+    get torchOnPressedImage(): string | null;
+    set torchOnPressedImage(torchOnPressedImage: string | null);
+}
+export class ZoomSwitchControl implements Control {
+    private type;
+    private icon;
+    private view;
+    get zoomedOutImage(): string | null;
+    set zoomedOutImage(zoomedOutImage: string | null);
+    get zoomedInImage(): string | null;
+    set zoomedInImage(zoomedInImage: string | null);
+    get zoomedInPressedImage(): string | null;
+    set zoomedInPressedImage(zoomedInPressedImage: string | null);
+    get zoomedOutPressedImage(): string | null;
+    set zoomedOutPressedImage(zoomedOutPressedImage: string | null);
+}
+export interface DataCaptureViewListener {
+    didChangeSize?(view: DataCaptureView, size: Size, orientation: Orientation): void;
+}
+export enum Anchor {
+    TopLeft = "topLeft",
+    TopCenter = "topCenter",
+    TopRight = "topRight",
+    CenterLeft = "centerLeft",
+    Center = "center",
+    CenterRight = "centerRight",
+    BottomLeft = "bottomLeft",
+    BottomCenter = "bottomCenter",
+    BottomRight = "bottomRight"
+}
+export class HTMLElementState {
+    isShown: boolean;
+    position: Optional<{
+        top: number;
+        left: number;
+    }>;
+    size: Optional<{
+        width: number;
+        height: number;
+    }>;
+    shouldBeUnderContent: boolean;
+    get isValid(): boolean;
+    didChangeComparedTo(other: HTMLElementState): boolean;
+}
+interface PrivateDataCaptureView {
+    htmlElement: Optional<HTMLElement>;
+    _htmlElementState: HTMLElementState;
+    htmlElementState: HTMLElementState;
+    readonly viewProxy: DataCaptureViewProxy;
+    _viewProxy: DataCaptureViewProxy;
+    overlays: DataCaptureOverlay[];
+    controls: Control[];
+    listeners: DataCaptureViewListener[];
+    addControl(control: Control): void;
+    removeControl(control: Control): void;
+    initialize(): void;
+    updatePositionAndSize(): void;
+    _show(): void;
+    _hide(): void;
+    elementDidChange(): void;
+    subscribeToChangesOnHTMLElement(): void;
+    controlUpdated(): void;
+}
+export class DataCaptureView {
+    private _context;
+    get context(): Optional<DataCaptureContext>;
+    set context(context: Optional<DataCaptureContext>);
+    scanAreaMargins: MarginsWithUnit;
+    pointOfInterest: PointWithUnit;
+    logoAnchor: Anchor;
+    logoOffset: PointWithUnit;
+    focusGesture: FocusGesture | null;
+    zoomGesture: ZoomGesture | null;
+    logoStyle: LogoStyle;
+    private overlays;
+    private controls;
+    private _viewProxy;
+    private get viewProxy();
+    private listeners;
+    private htmlElement;
+    private _htmlElementState;
+    private set htmlElementState(value);
+    private get htmlElementState();
+    private scrollListener;
+    private domObserver;
+    private orientationChangeListener;
+    /**
+     * The current context as a PrivateDataCaptureContext
+     */
+    private get privateContext();
+    static forContext(context: Optional<DataCaptureContext>): DataCaptureView;
+    constructor();
+    connectToElement(element: HTMLElement): void;
+    detachFromElement(): void;
+    setFrame(frame: Rect, isUnderContent?: boolean): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    addOverlay(overlay: DataCaptureOverlay): void;
+    removeOverlay(overlay: DataCaptureOverlay): void;
+    addListener(listener: DataCaptureViewListener): void;
+    removeListener(listener: DataCaptureViewListener): void;
+    viewPointForFramePoint(point: Point): Promise<Point>;
+    viewQuadrilateralForFrameQuadrilateral(quadrilateral: Quadrilateral): Promise<Quadrilateral>;
+    addControl(control: Control): void;
+    removeControl(control: Control): void;
+    private controlUpdated;
+    private initialize;
+    private subscribeToChangesOnHTMLElement;
+    private unsubscribeFromChangesOnHTMLElement;
+    private elementDidChange;
+    private updatePositionAndSize;
+    private _show;
+    private _hide;
+}
+
+export interface Serializeable {
+    toJSON: () => object;
+}
+export interface StringSerializeable {
+    toJSON: () => string;
+}
+export function ignoreFromSerialization(target: any, propertyName: string): void;
+export function nameForSerialization(customName: string): (target: any, propertyName: string) => void;
+export function ignoreFromSerializationIfNull(target: any, propertyName: string): void;
+export function serializationDefault(defaultValue: any): (target: any, propertyName: string) => void;
+export class DefaultSerializeable {
+    toJSON(): object;
+}
+
+
+export enum RectangularViewfinderStyle {
+    Legacy = "legacy",
+    Rounded = "rounded",
+    Square = "square"
+}
+export enum RectangularViewfinderLineStyle {
+    Light = "light",
+    Bold = "bold"
+}
+export enum LaserlineViewfinderStyle {
+    Legacy = "legacy",
+    Animated = "animated"
+}
+interface RectangularViewfinderAnimationJSON {
+    readonly looping: boolean;
+}
+interface PrivateRectangularViewfinderAnimation {
+    fromJSON(json: RectangularViewfinderAnimationJSON): RectangularViewfinderAnimation;
+}
+export class RectangularViewfinderAnimation {
+    private readonly _isLooping;
+    private static fromJSON;
+    get isLooping(): boolean;
+    constructor(isLooping: boolean);
+}
+
+}