@qr-platform/qr-code.js 0.8.24 → 0.9.1

package/lib/node/utils/options.d.ts

@@ -0,0 +1,220 @@
+import { Position } from '~/plugins/QRBorderHelpers';
+import { ErrorCorrectionLevel, Mode, TypeNumber } from '~/lib/qrcode/QRCodeMinimal';
+import { QRBorderPluginStyleOptions } from '../plugins/QRBorderPlugin';
+import { browserImageTools } from '../tools/browser-image-tools';
+import { Gradient } from './gradient';
+export interface DecorationOption {
+    disabled?: boolean;
+    offset?: number;
+    curveAdjustment?: number;
+    curveDisabled?: boolean;
+    curveRadius?: string;
+    enableText?: boolean;
+    type: 'text' | 'image';
+    value: string;
+    style?: QRBorderPluginStyleOptions;
+}
+export interface BorderOptions {
+    hasBorder: boolean;
+    radius?: string;
+    inner?: {
+        radius?: string;
+        scale?: number;
+        horizontalOffset?: number;
+        verticalOffset?: number;
+    };
+    innerScale?: number;
+    innerHorizontalOffset?: number;
+    innerVerticalOffset?: number;
+    thickness: number;
+    noBorderThickness?: number;
+    color: string;
+    background?: string;
+    decorations?: {
+        [key in Position]?: DecorationOption;
+    };
+    borderOuter?: {
+        color: string;
+        thickness: number;
+    };
+    borderInner?: {
+        color: string;
+        thickness: number;
+    };
+}
+export declare enum DotType {
+    dot = "dot",
+    randomDot = "random-dot",
+    rounded = "rounded",
+    extraRounded = "extra-rounded",
+    verticalLine = "vertical-line",
+    horizontalLine = "horizontal-line",
+    classy = "classy",
+    classyRounded = "classy-rounded",
+    square = "square",
+    smallSquare = "small-square",
+    tinySquare = "tiny-square",
+    star = "star",
+    plus = "plus",
+    diamond = "diamond"
+}
+export declare enum CornerDotType {
+    dot = "dot",
+    square = "square",
+    heart = "heart",
+    rounded = "rounded",
+    classy = "classy",
+    outpoint = "outpoint",
+    inpoint = "inpoint"
+}
+export declare enum CornerSquareType {
+    dot = "dot",
+    square = "square",
+    rounded = "rounded",
+    classy = "classy",
+    outpoint = "outpoint",
+    inpoint = "inpoint"
+}
+export declare enum ShapeType {
+    square = "square",
+    circle = "circle"
+}
+export declare enum ImageMode {
+    /**
+     * Place image in the center of the code
+     */
+    center = "center",
+    /**
+     * Place image over the center of the code
+     */
+    overlay = "overlay",
+    /**
+     * Use image as background, draw dots over it
+     */
+    background = "background"
+}
+export interface Options {
+    /** Use a custom DOM domplementation */
+    document: Document;
+    instanceId: number;
+    /** Use a custom image fetching & serializaton implementation */
+    imageTools?: typeof browserImageTools;
+    /** @ignore */
+    width?: number;
+    /** @ignore */
+    height?: number;
+    isResponsive?: boolean;
+    margin?: number;
+    verticalOffset?: number;
+    horizontalOffset?: number;
+    /** The data will be encoded in the QR code */
+    data: string;
+    /** The image will be copied to the center of the QR code */
+    image?: string | Buffer | Blob;
+    /**
+     * QR code shape
+     *
+     * @default ShapeType.square
+     */
+    shape: ShapeType;
+    /** Options will be passed to `~` lib */
+    scale?: number;
+    offset?: number;
+    qrOptions: {
+        typeNumber: TypeNumber;
+        mode?: Mode;
+        /** @default ErrorCorrectionLevel.Q */
+        errorCorrectionLevel: ErrorCorrectionLevel;
+    };
+    imageOptions: {
+        /**
+         * Image mode
+         *
+         * @default ImageMode.center
+         */
+        mode?: ImageMode;
+        /**
+         * Fill blank areas of the code with selected color
+         */
+        fill?: {
+            /**
+             * Color of QR dots
+             *
+             * @default "rgba(255,255,255,0.75)"
+             */
+            color: string;
+            /** Gradient of Corners Dot */
+            gradient?: Gradient;
+        };
+        /**
+         * Coefficient of the image size
+         *
+         * @default 0.4
+         */
+        imageSize: number;
+        /**
+         * Margin of the image (in blocks)
+         *
+         * @default 0
+         */
+        margin: number;
+        /**
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLImageElement/crossOrigin)
+         */
+        crossOrigin?: string;
+    };
+    dotsOptions: {
+        /**
+         * QR dot size (in pixels)
+         *
+         * @default 10
+         */
+        size: number;
+        /**
+         * Color of QR dots
+         *
+         * @default "#000"
+         */
+        color: string;
+        /** Gradient of QR dots */
+        gradient?: Gradient;
+        /**
+         * Style of QR dots
+         *
+         * @default DotType.square
+         */
+        type: DotType;
+    };
+    /** Corners Square options, omitted values match dots */
+    cornersSquareOptions?: {
+        /** Color of Corners Square */
+        color?: string;
+        /** Gradient of Corners Square */
+        gradient?: Gradient;
+        /** Style of Corners Square */
+        type?: CornerSquareType;
+    };
+    /** Corners Dot options, omitted values match squares */
+    cornersDotOptions?: {
+        /** Color of Corners Dot */
+        color?: string;
+        /** Gradient of Corners Dot */
+        gradient?: Gradient;
+        /** Style of Corners Dot */
+        type?: CornerDotType;
+    };
+    /** QR background styling options, false to disable background */
+    backgroundOptions?: {
+        /** Background roundnes, from 0 (square) to 1 (circle) */
+        round?: number;
+        /** Background color */
+        color?: string;
+        /** Background Gradient */
+        gradient?: Gradient;
+    } | false;
+    stringToBytesFuncs?: {
+        [encoding: string]: (s: string) => number[];
+    };
+    borderOptions?: BorderOptions;
+}
+export declare function sanitizeOptions(options: Options): Options;

package/lib/node/utils/qrcode.d.ts

@@ -0,0 +1,8 @@
+import { Mode } from '~/lib/qrcode/QRCodeMinimal';
+export declare const ErrorCorrectionPercents: {
+    L: number;
+    M: number;
+    Q: number;
+    H: number;
+};
+export declare function getMode(data: string): Mode;

package/lib/node/utils/scan-validator-node.d.ts

@@ -0,0 +1,15 @@
+import { ScanValidatorResponse } from './scan-validators/abstract-scan-validator';
+/**
+ * QR Code validator for Node.js environment
+ */
+export declare const qrValidator: {
+    /**
+     * Validate QR code using zbar with SVG as input
+     * @param svgSource SVG string containing QR code
+     * @param width Width to use for validation
+     * @param height Height to use for validation
+     * @param debug Enable detailed debugging
+     * @returns Validation result
+     */
+    validateZbar: (svgSource: string | undefined, debug?: boolean) => Promise<ScanValidatorResponse>;
+};

package/lib/node/utils/scan-validator-zxing-node.d.ts

@@ -0,0 +1,18 @@
+import { BinaryBitmap } from '~/lib/zxing-js/src';
+import { NodeLuminanceSource } from '~/lib/zxing-js/src/node';
+import { ScanValidatorResponse } from './scan-validators/abstract-scan-validator';
+export interface PreprocessingOptions {
+    lower?: number;
+    upper?: number;
+    gamma?: number;
+    threshold?: number;
+}
+/**
+ * Main QR Validator: attempts to decode the QR code from an SVG string.
+ * It tries the normal decode first, then with inverted luminance.
+ * (Alternative preprocessing attempt removed as it was identical to the first).
+ */
+export declare const qrValidatorZxing: {
+    validateZxing: (svgString: string | undefined) => Promise<ScanValidatorResponse>;
+};
+export type { NodeLuminanceSource, BinaryBitmap, ScanValidatorResponse };

package/lib/node/utils/scan-validators/abstract-scan-validator.d.ts

@@ -0,0 +1,43 @@
+import { BrowserQRCodeReader } from '~/lib/zxing-js/src';
+import QRCodeReader from '~/lib/zxing-js/src/core/qrcode/QRCodeReader';
+import QRValidatorZbar from '../../plugins/QRValidatorZbar';
+export interface ScanValidatorResponse {
+    /**
+     * Whether QR code was successfully validated
+     */
+    isValid: boolean;
+    /**
+     * Decoded data from the QR code
+     */
+    decodedText?: string | null;
+    /**
+     * Whether the successful decode was from an inverted image
+     */
+    isInverted?: boolean;
+    /**
+     * Additional message about the validation result
+     */
+    message?: string;
+    /**
+     * Number of attempts made during validation
+     */
+    attempts?: number;
+    /**
+     * Error code if validation failed
+     */
+    errorCode?: string;
+}
+declare class AbstractScanValidator {
+    debug: boolean;
+    validatorName: string;
+    log(message: any): void;
+}
+export default AbstractScanValidator;
+export interface ScanValidator {
+    validator: QRValidatorZbar | QRCodeReader | BrowserQRCodeReader;
+    validate(...args: any): Promise<ScanValidatorResponse>;
+}
+export interface DecodeAttempt {
+    name: string;
+    execute(): Promise<ScanValidatorResponse>;
+}

package/lib/node/utils/scan-validators/zbar-scan-validator.d.ts

@@ -0,0 +1,8 @@
+import QRValidatorZbar from '../../plugins/QRValidatorZbar';
+import AbstractScanValidator, { ScanValidator, ScanValidatorResponse } from './abstract-scan-validator';
+declare class ZBarScanValidator extends AbstractScanValidator implements ScanValidator {
+    validator: QRValidatorZbar;
+    constructor(debug?: boolean);
+    validate(svgSource: string | undefined, getSvgInverted: () => Promise<string | undefined>, width: number, height: number, debug?: boolean): Promise<ScanValidatorResponse>;
+}
+export default ZBarScanValidator;

package/lib/node/utils/scan-validators/zxing-canvas-scan-validator.d.ts

@@ -0,0 +1,10 @@
+import { LuminanceSource } from '~/lib/zxing-js/src';
+import QRCodeReader from '~/lib/zxing-js/src/core/qrcode/QRCodeReader';
+import AbstractScanValidator, { ScanValidator, ScanValidatorResponse } from './abstract-scan-validator';
+declare class ZXingCanvasScanValidator extends AbstractScanValidator implements ScanValidator {
+    validator: QRCodeReader;
+    constructor(debug?: boolean);
+    displayLuminanceSource(source: LuminanceSource, label: string): void;
+    validate(canvas: HTMLCanvasElement, debug?: boolean): Promise<ScanValidatorResponse>;
+}
+export default ZXingCanvasScanValidator;

package/lib/node/utils/scan-validators/zxing-scan-validator.d.ts

@@ -0,0 +1,8 @@
+import { BrowserQRCodeReader } from '~/lib/zxing-js/src';
+import AbstractScanValidator, { ScanValidator, ScanValidatorResponse } from './abstract-scan-validator';
+declare class ZXingScanValidator extends AbstractScanValidator implements ScanValidator {
+    validator: BrowserQRCodeReader;
+    constructor(debug?: boolean);
+    validate(svgSource: string | undefined, getSvgInverted: () => Promise<string | undefined>, debug?: boolean): Promise<ScanValidatorResponse>;
+}
+export default ZXingScanValidator;

package/lib/node/utils/style-mapper.d.ts

@@ -0,0 +1,13 @@
+import { RecursivePartial } from '../types/helper';
+import { StyleOptions } from '../types/style-options';
+import { Options } from './options';
+/**
+ * Maps simplified StyleOptions to the detailed QRCodeJs Options structure.
+ * @param styles - The StyleOptions object to map.
+ * @returns A RecursivePartial<Options> object reflecting the styles.
+ */
+export declare function mapStyleToOptions(styles: StyleOptions): RecursivePartial<Options>;
+export declare function validateStyleOptions(styles: any): {
+    isValid: boolean;
+    errors: string[];
+};

package/lib/node/utils/svg.d.ts

@@ -0,0 +1,2 @@
+export declare function numToAttr(value: number): string;
+export declare function svgPath(strings: TemplateStringsArray, ...values: unknown[]): string;

package/lib/node/utils/token-validator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents the decoded payload of a valid license token.
+ */
+export interface DecodedLicenseToken {
+    sub: string;
+    client: string;
+    email?: string;
+    domains?: string[];
+    iat: number;
+    exp: number;
+}
+/**
+ * Validates a JWT access token using the public key.
+ *
+ * @param token The JWT token string to validate.
+ * @returns The decoded token payload if the token is valid and not expired.
+ * @throws {Error} If the token is invalid, expired, or verification fails for any other reason.
+ */
+export declare function validateToken(token: string): Promise<DecodedLicenseToken>;

package/lib/node.d.ts

@@ -2,6 +2,7 @@ import { QRCodeJs as _QRCodeJs } from './core/qr-code-js';
 import { type ValidationResult } from './license/LicenseManagerNode';
 import type * as _browserUtils from './tools/browser-utils';
 import { RecursivePartial } from './types/helper';
+import { StyleOptions } from './types/style-options';
 import { Options } from './utils/options';
 import { ScanValidatorResponse } from './utils/scan-validators/abstract-scan-validator';
 import { type DecodedLicenseToken } from './utils/token-validator';
@@ -28,31 +29,58 @@ export declare class QRCodeJs extends _QRCodeJs {
      * @param url The absolute URL for fetching license tokens (e.g., https://api.example.com/get-token).
      */
     static setLicenseUrl(url: string): typeof QRCodeJs;
-    constructor(options: RecursivePartial<Options>);
+    static _xmldomSync: any;
+    static _initPromise: Promise<void> | null;
+    static initXmldom(): Promise<void>;
+    constructor(options: RecursivePartial<Options>, _?: boolean);
     validateScanning(): Promise<ScanValidatorResponse>;
     /**
      * Creates a QRCodeBuilder instance initialized with a specific template.
      * Allows for fluent configuration chaining. We need it here to avoid circular dependency
      * @param templateName - The name of the template to start with.
+     * @param templateNameOrOptions - The name of the template or a partial options object to start with.
      * @returns A new QRCodeBuilder instance.
      */
-    static useTemplate(templateName: string): QRCodeBuilder<QRCodeJs>;
+    static useTemplate(templateNameOrOptions: string | RecursivePartial<Options>): QRCodeBuilder;
+    /**
+     * Creates a QRCodeBuilder instance initialized with a specific style.
+     * Allows for fluent configuration chaining.
+     * @param styleNameOrOptions - The name of the predefined style or a StyleOptions object.
+     * @returns A new QRCodeBuilder instance.
+     */
+    static useStyle(styleNameOrOptions: string | StyleOptions): QRCodeBuilder;
 }
-type QRCodeJsConstructor<T extends QRCodeJs = QRCodeJs> = new (options: Options) => T;
-declare class QRCodeBuilder<T extends QRCodeJs> {
+declare class QRCodeBuilder {
     protected config: RecursivePartial<Options>;
-    protected qrCodeJsConstructor: QRCodeJsConstructor<T>;
     /**
-     * Creates a new QRCodeBuilderCore instance.
-     * @param templateName - Optional name of a predefined template to start with.
+     * Creates a new QRCodeBuilder instance.
+     * @param templateNameOrOptions - Optional name of a predefined template or a partial options object to start with.
+     */
+    constructor(templateNameOrOptions?: string | RecursivePartial<Options>);
+    /**
+     * Applies a template to the builder's configuration. Template options
+     * will be overridden by subsequently chained .style() or .options() calls.
+     * @param templateNameOrOptions - The name of the template or a partial options object to apply.
+     * @returns The builder instance for chaining.
+     */
+    useTemplate(templateNameOrOptions: string | RecursivePartial<Options>): this;
+    /**
+     * Applies style options to the builder's configuration.
+     * @param styleNameOrOptions - Name of a predefined style or Style options object to apply.
+     * @returns The builder instance for chaining.
      */
-    constructor(templateName?: string);
+    useStyle(styleNameOrOptions: string | StyleOptions): this;
     /**
-     * Merges the provided options into the builder's configuration and creates the QRCodeJs instance.
+     * Merges the provided options into the builder's configuration.
      * @param options - A partial options object to merge.
+     * @returns The builder instance for chaining.
+     */
+    options(options: RecursivePartial<Options>): QRCodeJs;
+    /**
+     * Builds the QRCodeJs instance with the accumulated configuration.
      * @returns The created QRCodeJs instance.
      */
-    options(options: RecursivePartial<Options>): T;
+    build(): QRCodeJs;
 }
 export declare class _ extends QRCodeJs {
     protected _hls(): boolean;