@taybart/corvid 0.1.4 → 0.1.6

package/README.md

@@ -116,3 +116,14 @@ style.onDarkMode((isDark) => {
     console.log(`is dark mode: ${isDark} and background is ${style.cssVar('--color-bg')`)
 })
 ```
+
+### QR
+
+```js
+import { QR } '@taybart/corvid/qr'
+
+QR.render({
+    text: 'https://example.com',
+    size: 200,
+}, document.getElementById('qr'))
+```

package/dist/dom.d.ts

@@ -7,12 +7,13 @@ import { logger } from './utils';
  * onDomContentLoaded callback
  */
 export declare function ready(cb: () => void): void;
+export declare function on(event: string, cb: (ev: Event) => void): () => void;
 export declare function onKey(key: string, cb: (ev: {
     ctrl: boolean;
     alt: boolean;
     meta: boolean;
     shift: boolean;
-}) => void): void;
+}) => void, verbose?: boolean): () => void;
 export declare function els(query: string, verbose?: boolean): el[];
 /*** element ***/
 type elOpts = {
@@ -36,6 +37,7 @@ export declare class el {
     parent(parent: HTMLElement | el): this;
     appendChild(ch: HTMLElement | el): this;
     child(ch: HTMLElement | el): this;
+    prependChild(ch: HTMLElement | el): this;
     empty(): this;
     content(content: any, { text }?: {
         text?: boolean;

package/dist/index.js

@@ -43,6 +43,7 @@ __webpack_require__.d(dom_namespaceObject, {
     el: ()=>dom_el,
     els: ()=>els,
     interpolate: ()=>interpolate,
+    on: ()=>on,
     onKey: ()=>onKey,
     ready: ()=>ready
 });
@@ -158,16 +159,23 @@ function genID(len = 15, alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg
     ].map((value)=>alphabet[Math.floor(value / 255 * alphabet.length)]).join('');
 }
 const clipboard = {
+    check () {
+        if (!navigator.clipboard) throw new Error('Clipboard API not supported, or context is not https');
+    },
     async copy (text) {
+        this.check();
         await navigator.clipboard.writeText(text);
     },
     async copyArbitrary (data) {
+        this.check();
         await navigator.clipboard.write(data);
     },
     async read () {
+        this.check();
         return await navigator.clipboard.readText();
     },
     async readArbitrary () {
+        this.check();
         return await navigator.clipboard.read();
     },
     listen (query, cb) {
@@ -242,15 +250,28 @@ function dom_define_property(obj, key, value) {
 function ready(cb) {
     window.addEventListener('DOMContentLoaded', cb);
 }
-function onKey(key, cb) {
-    window.addEventListener('keydown', (ev)=>{
+function on(event, cb) {
+    document.addEventListener(event, cb);
+    return ()=>{
+        document.removeEventListener(event, cb);
+    };
+}
+function onKey(key, cb, verbose = false) {
+    const log = new logger(verbose ? utils_logLevel.debug : utils_logLevel.none, 'onKey');
+    log.debug(`adding ${key} keydown listener`);
+    const handler = (ev)=>{
         if (ev.key === key) cb({
             ctrl: ev.ctrlKey,
             alt: ev.altKey,
             meta: ev.metaKey,
             shift: ev.shiftKey
         });
-    });
+    };
+    window.addEventListener('keydown', handler);
+    return ()=>{
+        log.debug(`removing ${key} listener`);
+        window.removeEventListener('keydown', handler);
+    };
 }
 function els(query, verbose = false) {
     return Array.from(document.querySelectorAll(query)).map((n)=>new dom_el(n, verbose));
@@ -283,6 +304,12 @@ class dom_el {
         else this.el.appendChild(ch);
         return this;
     }
+    prependChild(ch) {
+        if (!this.el) throw new Error(`no element from query: ${this.query}`);
+        if (ch instanceof dom_el) this.el.prepend(ch.el);
+        else this.el.prepend(ch);
+        return this;
+    }
     empty() {
         if (this.el) this.el.innerHTML = '';
         return this;

package/dist/qr/index.d.ts

@@ -0,0 +1,41 @@
+export interface QRCodeConfig {
+    text: string;
+    size?: number;
+    fill?: string | GradientFill;
+    background?: string | null;
+    ecLevel?: 'L' | 'M' | 'Q' | 'H';
+    minVersion?: number;
+    maxVersion?: number;
+    radius?: number;
+    quiet?: number;
+    left?: number;
+    top?: number;
+}
+export interface GradientFill {
+    type: 'linear-gradient' | 'radial-gradient';
+    position: number[];
+    colorStops: [number, string][];
+}
+export interface QRCode {
+    text: string;
+    level: string;
+    version: number;
+    moduleCount: number;
+    isDark: (row: number, col: number) => boolean;
+}
+export declare class QR {
+    static render(config: QRCodeConfig, element: HTMLElement | HTMLCanvasElement): void;
+    private static getDefaultSettings;
+    private static createQRCode;
+    private static createMinQRCode;
+    private static drawBackground;
+    private static drawModuleRoundedDark;
+    private static drawModuleRoundedLight;
+    private static drawModuleRounded;
+    private static drawModules;
+    private static setFill;
+    private static drawOnCanvas;
+    private static createCanvas;
+    private static renderToCanvas;
+}
+export default QR;

package/dist/qr/qr-generator.d.ts

@@ -0,0 +1,71 @@
+export declare class QRCodeGenerator {
+    private typeNumber;
+    private errorCorrectLevel;
+    private modules;
+    private moduleCount;
+    private dataCache;
+    private dataList;
+    constructor(typeNumber: number, errorCorrectLevel: string);
+    addData(data: string): void;
+    isDark(row: number, col: number): boolean;
+    getModuleCount(): number;
+    make(): void;
+    private makeImpl;
+    private createModules;
+    private setupPositionProbePattern;
+    private getBestMaskPattern;
+    private setupTimingPattern;
+    private setupPositionAdjustPattern;
+    private setupTypeNumber;
+    private setupTypeInfo;
+    private mapData;
+    private createBytes;
+    private getErrorCorrectPolynomial;
+    private createData;
+    static stringToBytes(s: string): number[];
+}
+export declare class QR8BitByte {
+    private mode;
+    private data;
+    private bytes;
+    constructor(data: string);
+    getMode(): number;
+    getLength(): number;
+    write(buffer: QRBitBuffer): void;
+}
+export declare class QRBitBuffer {
+    private buffer;
+    private length;
+    getBuffer(): number[];
+    getAt(index: number): boolean;
+    put(num: number, length: number): void;
+    getLengthInBits(): number;
+    putBit(bit: boolean): void;
+}
+export declare class QRPolynomial {
+    private num;
+    constructor(num: number[], shift: number);
+    getAt(index: number): number;
+    getLength(): number;
+    multiply(e: QRPolynomial): QRPolynomial;
+    mod(e: QRPolynomial): QRPolynomial;
+}
+export declare const QRMode: {
+    readonly MODE_8BIT_BYTE: number;
+};
+export declare const QRErrorCorrectLevel: {
+    readonly L: 1;
+    readonly M: 0;
+    readonly Q: 3;
+    readonly H: 2;
+};
+export declare const QRMaskPattern: {
+    readonly PATTERN000: 0;
+    readonly PATTERN001: 1;
+    readonly PATTERN010: 2;
+    readonly PATTERN011: 3;
+    readonly PATTERN100: 4;
+    readonly PATTERN101: 5;
+    readonly PATTERN110: 6;
+    readonly PATTERN111: 7;
+};

package/dist/qr/qr-utils.d.ts

@@ -0,0 +1,28 @@
+export declare class QRUtil {
+    private static PATTERN_POSITION_TABLE;
+    private static G15;
+    private static G18;
+    private static G15_MASK;
+    private static getBCHDigit;
+    static getBCHTypeInfo(data: number): number;
+    static getBCHTypeNumber(data: number): number;
+    static getPatternPosition(typeNumber: number): number[];
+    static getMaskFunction(maskPattern: number): (i: number, j: number) => boolean;
+    static getErrorCorrectPolynomial(errorCorrectLength: number): any;
+    static getLengthInBits(mode: number, type: number): number;
+    static getLostPoint(qrcode: any): number;
+}
+export declare class QRMath {
+    private static EXP_TABLE;
+    private static LOG_TABLE;
+    static glog(n: number): number;
+    static gexp(n: number): number;
+}
+export declare class QRRSBlock {
+    private static RS_BLOCK_TABLE;
+    totalCount: number;
+    dataCount: number;
+    constructor(totalCount: number, dataCount: number);
+    private static getRsBlockTable;
+    static getRSBlocks(typeNumber: number, errorCorrectLevel: number): QRRSBlock[];
+}