@taybart/corvid 0.1.5 → 0.1.7

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,6 +7,7 @@ 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;
@@ -20,7 +21,7 @@ type elOpts = {
     query?: string;
     type?: string;
     content?: any;
-    class?: string;
+    class?: string | string[];
     style?: Object;
     id?: string;
     parent?: HTMLElement | el;
@@ -45,8 +46,8 @@ export declare class el {
     /*** Style ***/
     style(update: Object | string, stringify?: boolean): this | undefined;
     hasClass(className: string): boolean;
-    addClass(className: string): this;
-    removeClass(className: string): this;
+    addClass(className: string | string[]): this;
+    removeClass(className: string | string[]): this;
     /*** Templates ***/
     render(vars?: {}): string;
     appendTemplate(template: el, vars: any): void;

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,6 +250,12 @@ function dom_define_property(obj, key, value) {
 function ready(cb) {
     window.addEventListener('DOMContentLoaded', cb);
 }
+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`);
@@ -331,12 +345,14 @@ class dom_el {
     }
     addClass(className) {
         if (!this.el) throw new Error(`no element from query: ${this.query}`);
-        this.el.classList.add(className);
+        if ('string' == typeof className) this.el.classList.add(className);
+        else for (const sc of className)this.el.classList.add(sc);
         return this;
     }
     removeClass(className) {
         if (!this.el) throw new Error(`no element from query: ${this.query}`);
-        this.el.classList.remove(className);
+        if ('string' == typeof className) this.el.classList.remove(className);
+        else for (const sc of className)this.el.classList.remove(sc);
         return this;
     }
     render(vars = {}) {
@@ -365,6 +381,7 @@ class dom_el {
     }
     removeListeners(event) {
         if (!this.el) throw new Error(`no element from query: ${this.query}`);
+        if (!this.listeners[event]) return this;
         for (const cb of this.listeners[event])this.el.removeEventListener(event, cb);
         this.listeners[event] = [];
         return this;
@@ -404,7 +421,8 @@ class dom_el {
                 this.log.debug(`setting id: ${id}`);
                 this.el.id = id;
             }
-            if (styleClass) this.el.classList.add(styleClass);
+            if (styleClass) if ('string' == typeof styleClass) this.el.classList.add(styleClass);
+            else for (const sc of styleClass)this.el.classList.add(sc);
             if (style) this.style(style);
             if (content) {
                 this.log.debug(`setting content: ${content}`);
@@ -469,14 +487,16 @@ class request {
         this.opts.body = body;
         return this;
     }
-    async do({ path, override } = {}) {
+    async do({ path, params: passedParams, override } = {}) {
         if (this.opts.auth) this.opts.headers.Authorization = `Bearer ${this.opts.auth}`;
         if (!override) override = {};
         const body = override.body || this.opts.body;
         let url = this.opts.url;
         if (path) url = `${this.opts.url}${path}`;
-        const params = override.params || this.opts.params;
-        if (params) url = `${url}?${params.toString()}`;
+        let reqParams;
+        if (override.params || this.opts.params) reqParams = new network_params(override.params || this.opts.params);
+        if (passedParams) reqParams = reqParams ? new network_params(reqParams).set(passedParams) : new network_params(passedParams);
+        if (reqParams) url = `${url}?${reqParams.toString()}`;
         this.log.debug(`${this.opts.method} ${url}`);
         const res = await fetch(url, {
             method: this.opts.method,

package/dist/network.d.ts

@@ -12,7 +12,7 @@ export type requestOpts = {
     url?: string;
     type?: 'json';
     method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
-    params?: typeof params;
+    params?: Object | params;
     headers?: Record<string, string>;
     auth?: string;
     body?: Object;
@@ -26,11 +26,12 @@ export declare class request {
     auth(token: string): this;
     basicAuth(username: string, password: string): this;
     body(body: Object): this;
-    do({ path, override, }?: {
+    do({ path, params: passedParams, override, }?: {
         path?: string;
+        params?: Object;
         override?: {
             success?: number;
-            params?: any;
+            params?: Object;
             body?: Object;
         };
     }): Promise<any>;

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[];
+}