@taybart/corvid 0.0.7 → 0.1.0

package/README.md

@@ -1 +1,6 @@
 # Corvid
+
+fear the crow
+
+
+![crowtein_2](https://github.com/user-attachments/assets/b3bbf267-d7b0-4116-80a5-b932b409a111)

package/dist/crypto.d.ts

@@ -0,0 +1,8 @@
+export declare class EncryptionHelper {
+    private iv?;
+    private aesKey?;
+    private encryptionKey?;
+    constructor(publicKey: string);
+    encrypt(plaintext: string): Promise<string>;
+    key(): Promise<string>;
+}

package/dist/dom.d.ts

@@ -1,36 +1,50 @@
+import { logger } from './utils';
 /****************
  *     DOM      *
  ***************/
 /*** window ***/
 /**
- * onDomContentLoaded
+ * onDomContentLoaded callback
  */
 export declare function ready(cb: () => void): void;
+export declare function onKey(key: string, cb: (ev: {
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+    shift: boolean;
+}) => void): void;
 /*** element ***/
 type elOpts = {
+    element?: HTMLElement;
     query?: string;
     type?: string;
     content?: any;
-    parent?: HTMLElement;
-    create?: boolean;
+    class?: string;
+    style?: Object;
+    id?: string;
+    parent?: HTMLElement | el;
 };
 export declare class el {
     el: HTMLElement | null;
     query: string;
-    constructor(opts: string | elOpts);
-    /*** get ***/
-    value(): string;
-    /*** set ***/
-    parent(parent: HTMLElement): this;
-    child(ch: HTMLElement): this;
-    inner(content: any, { force, text }?: {
-        force?: boolean;
+    log: logger;
+    constructor(opts: HTMLElement | string | elOpts, verbose?: boolean);
+    /*** dom manipulation ***/
+    value(update?: string): string | el;
+    parent(parent: HTMLElement | el): this;
+    appendChild(ch: HTMLElement | el): this;
+    child(ch: HTMLElement | el): this;
+    empty(): this;
+    content(content: any, { text }?: {
         text?: boolean;
     }): this;
     src(url: string): this;
+    /*** Style ***/
     style(style: Object | string): this;
     addClass(className: string): this;
     removeClass(className: string): this;
+    /*** Events ***/
+    on(event: string, cb: (ev: Event) => void): this;
     listen(event: string, cb: (ev: Event) => void): this;
     onClick(cb: (ev: Event) => void): this;
 }

package/dist/index.js

@@ -23,7 +23,8 @@ var __webpack_require__ = {};
 var dom_namespaceObject = {};
 __webpack_require__.r(dom_namespaceObject);
 __webpack_require__.d(dom_namespaceObject, {
-    el: ()=>el,
+    el: ()=>dom_el,
+    onKey: ()=>onKey,
     ready: ()=>ready
 });
 var style_namespaceObject = {};
@@ -39,7 +40,9 @@ var network_namespaceObject = {};
 __webpack_require__.r(network_namespaceObject);
 __webpack_require__.d(network_namespaceObject, {
     params: ()=>network_params,
-    request: ()=>request
+    refresh: ()=>refresh,
+    request: ()=>request,
+    ws: ()=>ws
 });
 var local_storage_namespaceObject = {};
 __webpack_require__.r(local_storage_namespaceObject);
@@ -48,6 +51,9 @@ __webpack_require__.d(local_storage_namespaceObject, {
     listen: ()=>listen,
     set: ()=>set
 });
+function toKebab(str) {
+    return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (s, ofs)=>(ofs ? '-' : '') + s.toLowerCase());
+}
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -58,12 +64,119 @@ function _define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
+function genID(len = 15, alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz') {
+    return [
+        ...crypto.getRandomValues(new Uint8Array(len))
+    ].map((value)=>alphabet[Math.floor(value / 255 * alphabet.length)]).join('');
+}
+const clipboard = {
+    async copy (text) {
+        await navigator.clipboard.writeText(text);
+    },
+    async copyArbitrary (data) {
+        await navigator.clipboard.write(data);
+    },
+    async read () {
+        return await navigator.clipboard.readText();
+    },
+    async readArbitrary () {
+        return await navigator.clipboard.read();
+    },
+    listen (query, cb) {
+        let el;
+        el = 'string' == typeof query ? document.querySelector(query) : query;
+        if (!el) throw new Error(`no element from query: ${query}`);
+        el.addEventListener('copy', (ev)=>{
+            const cbEv = ev;
+            const selection = document.getSelection();
+            if (selection) {
+                const text = selection.toString();
+                if (text && cbEv.clipboardData) cbEv.clipboardData.setData('text/plain', cb(text));
+            }
+        });
+    }
+};
+var utils_logLevel = /*#__PURE__*/ function(logLevel) {
+    logLevel[logLevel["none"] = -1] = "none";
+    logLevel[logLevel["error"] = 0] = "error";
+    logLevel[logLevel["warn"] = 1] = "warn";
+    logLevel[logLevel["info"] = 2] = "info";
+    logLevel[logLevel["debug"] = 3] = "debug";
+    logLevel[logLevel["trace"] = 4] = "trace";
+    return logLevel;
+}({});
+class logger {
+    error(...args) {
+        if (this.level >= 0) console.error(`[corvid] ${this.prefix}`, ...args);
+    }
+    warn(...args) {
+        if (this.level >= 1) console.warn(`[corvid] ${this.prefix}`, ...args);
+    }
+    info(...args) {
+        if (this.level >= 2) console.info(`[corvid] ${this.prefix}`, ...args);
+    }
+    debug(...args) {
+        if (this.level >= 3) console.debug(`[corvid] ${this.prefix}`, ...args);
+    }
+    trace(...args) {
+        if (this.level >= 4) console.trace(`[corvid] ${this.prefix}`, ...args);
+    }
+    log(...args) {
+        console.log(`[corvid] ${this.prefix}`, ...args);
+    }
+    constructor(level = 2, prefix){
+        _define_property(this, "level", void 0);
+        _define_property(this, "prefix", void 0);
+        this.level = level;
+        this.prefix = prefix ? `(${prefix}):` : ':';
+        if (-1 === this.level) {
+            const methodsToMock = [
+                'error',
+                'warn',
+                'info',
+                'debug',
+                'trace',
+                'log'
+            ];
+            methodsToMock.forEach((methodName)=>{
+                this[methodName] = ()=>{};
+            });
+        }
+    }
+}
+function dom_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
 function ready(cb) {
     window.addEventListener('DOMContentLoaded', cb);
 }
-class el {
-    value() {
-        if (this.el && this.el instanceof HTMLInputElement) return this.el.value;
+function onKey(key, cb) {
+    window.addEventListener('keydown', (ev)=>{
+        if (ev.key === key) cb({
+            ctrl: ev.ctrlKey,
+            alt: ev.altKey,
+            meta: ev.metaKey,
+            shift: ev.shiftKey
+        });
+    });
+}
+class dom_el {
+    value(update) {
+        if (!this.el) throw new Error(`no element from query: ${this.query}`);
+        if (update) {
+            if ('value' in this.el) this.el.value = update;
+            if ('src' in this.el) this.el.src = update;
+            return this;
+        }
+        if ('value' in this.el) return this.el.value;
+        this.log.warn(`element (${this.query}) does not contain value, returning empty string`);
         return '';
     }
     parent(parent) {
@@ -71,22 +184,27 @@ class el {
         parent.appendChild(this.el);
         return this;
     }
+    appendChild(ch) {
+        return this.child(ch);
+    }
     child(ch) {
-        var _this_el;
         if (!this.el) throw new Error(`no element from query: ${this.query}`);
-        null == (_this_el = this.el) || _this_el.appendChild(ch);
+        if (ch instanceof dom_el) this.el.appendChild(ch.el);
+        else this.el.appendChild(ch);
+        return this;
+    }
+    empty() {
+        if (this.el) this.el.innerHTML = '';
         return this;
     }
-    inner(content, { force = false, text = false } = {}) {
+    content(content, { text = false } = {}) {
         if (!this.el) throw new Error(`no element from query: ${this.query}`);
-        if (this.el instanceof HTMLIFrameElement && !force) this.el.src = content;
-        else if (this.el instanceof HTMLInputElement && !force) this.el.value = content;
-        else if (text) this.el.textContent = content;
+        if (text) this.el.textContent = content;
         else this.el.innerHTML = content;
         return this;
     }
     src(url) {
-        if (this.el instanceof HTMLIFrameElement || this.el instanceof HTMLImageElement) this.el.src = url;
+        if (this.el && 'src' in this.el) this.el.src = url;
         return this;
     }
     style(style) {
@@ -94,7 +212,7 @@ class el {
             if ('string' == typeof style) this.el.style = style;
             else if ('object' == typeof style) {
                 let s = '';
-                Object.entries(style).forEach(([k, v])=>s += `${k}:${v};`);
+                Object.entries(style).forEach(([k, v])=>s += `${toKebab(k)}:${v};`);
                 this.el.style = s;
             }
         }
@@ -110,32 +228,56 @@ class el {
         this.el.classList.remove(className);
         return this;
     }
-    listen(event, cb) {
+    on(event, cb) {
         if (!this.el) throw new Error(`no element from query: ${this.query}`);
         this.el.addEventListener(event, cb);
         return this;
     }
+    listen(event, cb) {
+        return this.on(event, cb);
+    }
     onClick(cb) {
-        return this.listen('click', cb);
+        return this.on('click', cb);
     }
-    constructor(opts){
-        _define_property(this, "el", void 0);
-        _define_property(this, "query", void 0);
-        this.query = '';
+    constructor(opts, verbose = false){
+        dom_define_property(this, "el", void 0);
+        dom_define_property(this, "query", '');
+        dom_define_property(this, "log", void 0);
+        this.log = new logger(verbose ? utils_logLevel.debug : utils_logLevel.none, 'element');
         if ('string' == typeof opts) {
             this.query = opts;
             this.el = document.querySelector(opts);
             return;
         }
-        const { query, type, content, parent, create } = opts;
+        const { query, element, type, class: styleClass, style, id, content, parent } = opts;
         if (query) {
+            this.log.debug(`using query: ${query}`);
             this.query = query;
             this.el = document.querySelector(query);
-            if (!this.el && type && create) this.el = document.createElement(type);
-        } else if (type) this.el = document.createElement(type);
-        else throw new Error('no query or type provided');
-        if (this.el && content) this.el.innerHTML = content;
-        if (this.el && parent) parent.appendChild(this.el);
+            if (!this.el) throw new Error(`no element from query: ${query}`);
+        } else if (element) {
+            this.log.debug(`using existing element: ${element}`);
+            this.el = element;
+        } else if (type) {
+            this.log.debug(`creating element: ${type}`);
+            this.el = document.createElement(type);
+        } else throw new Error('no query or type provided');
+        if (this.el) {
+            if (id) {
+                this.log.debug(`setting id: ${id}`);
+                this.el.id = id;
+            }
+            if (styleClass) this.el.classList.add(styleClass);
+            if (style) this.style(style);
+            if (content) {
+                this.log.debug(`setting content: ${content}`);
+                this.el.innerHTML = content;
+            }
+            if (parent) {
+                this.log.debug("adding to parent");
+                parent.appendChild(this.el);
+            }
+        }
     }
 }
 function cssVar(name) {
@@ -192,11 +334,15 @@ class network_params {
 }
 class request {
     auth(token) {
-        this.opts.headers.Authorization = `Bearer ${token}`;
+        const header = `Bearer ${token}`;
+        this.log.debug(`adding auth token header ${header}`);
+        this.opts.headers.Authorization = header;
         return this;
     }
     basicAuth(username, password) {
-        this.opts.headers.Authorization = 'Basic ' + btoa(username + ':' + password);
+        const header = `Basic ${btoa(`${username}:${password}`)}`;
+        this.log.debug(`adding basic auth header ${header}`);
+        this.opts.headers.Authorization = header;
         return this;
     }
     body(body) {
@@ -211,8 +357,10 @@ class request {
         if (path) url = `${this.opts.url}${path}`;
         const params = override.params || this.opts.params;
         if (params) url = `${url}?${params.toString()}`;
+        this.log.debug(`${this.opts.method} ${url}`);
         const res = await fetch(url, {
             method: this.opts.method,
+            credentials: this.opts.credentials,
             headers: {
                 accept: 'application/json',
                 'content-type': 'application/json',
@@ -227,14 +375,109 @@ class request {
         }
         return await res.json();
     }
-    constructor(opts = {}){
+    constructor(opts = {}, verbose = false){
         network_define_property(this, "opts", void 0);
+        network_define_property(this, "log", void 0);
+        this.log = new logger(verbose ? utils_logLevel.debug : utils_logLevel.none, 'request');
         if (opts.type && 'json' !== opts.type) throw new Error('this class only provides json requests');
         if (!opts.url) throw new Error('must provide url');
         this.opts = opts;
         if (!this.opts.success) this.opts.success = 200;
         if (!this.opts.method) this.opts.method = 'GET';
         if (!this.opts.headers) this.opts.headers = {};
+        if (!this.opts.credentials) this.opts.credentials = 'omit';
+        this.log.debug(`with options: ${JSON.stringify(this.opts)}`);
+    }
+}
+class ws {
+    setup() {
+        this.recursion_level += 1;
+        this.ws = new WebSocket(this.url);
+        this.backoff = 100;
+        this.ws.addEventListener('open', ()=>{
+            const rl = this.recursion_level;
+            this.log.debug(`on open: reconnected (${rl})`);
+            this.is_connected = true;
+            for(let key in this.event_listeners)this.event_listeners[key].forEach((cb)=>{
+                this.log.debug(`adding listener (${rl}): ${key}`);
+                this.ws.addEventListener(key, cb);
+            });
+        });
+        this.ws.addEventListener('close', ()=>{
+            this.log.debug('connection closed');
+            this.is_connected = false;
+            this.backoff = Math.min(2 * this.backoff, this.max_timeout);
+            this.log.debug('backoff: ' + this.backoff);
+            setTimeout(()=>{
+                if (this.should_reconnect) {
+                    this.ws = null;
+                    this.setup();
+                }
+            }, this.backoff + 50 * Math.random());
+        });
+    }
+    send(data) {
+        if (!this.is_connected || !this.ws) throw new Error('not connected');
+        this.ws.send(data);
+    }
+    onMessage(cb) {
+        if (!this.ws) throw new Error('ws is null');
+        if (!this.event_listeners.message) this.event_listeners.message = [];
+        this.event_listeners.message.push((e)=>{
+            const rl = this.recursion_level;
+            this.log.debug(`message(${rl}): ${e.data}`);
+            cb(e.data);
+        });
+        this.ws.addEventListener('message', (e)=>{
+            const rl = this.recursion_level;
+            this.log.debug(`message(${rl}): ${e.data}`);
+            cb(e.data);
+        });
+    }
+    on(event, cb) {
+        if (!this.ws) throw new Error('ws is null');
+        if (!this.event_listeners[event]) this.event_listeners[event] = [];
+        this.event_listeners[event].push(cb);
+        this.ws.addEventListener(event, cb);
+    }
+    close() {
+        if (!this.is_connected || !this.ws) return;
+        this.should_reconnect = false;
+        this.ws.close();
+    }
+    constructor(url, verbose = false){
+        network_define_property(this, "url", void 0);
+        network_define_property(this, "ws", void 0);
+        network_define_property(this, "backoff", 50);
+        network_define_property(this, "max_timeout", 10000);
+        network_define_property(this, "should_reconnect", true);
+        network_define_property(this, "is_connected", false);
+        network_define_property(this, "recursion_level", 0);
+        network_define_property(this, "log", void 0);
+        network_define_property(this, "event_listeners", {});
+        this.url = url;
+        this.ws = null;
+        this.log = new logger(verbose ? utils_logLevel.debug : utils_logLevel.none, 'websocket');
+        this.setup();
+    }
+}
+class refresh {
+    listen() {
+        const socket = new ws(this.url);
+        if (socket) {
+            socket.on('open', ()=>{
+                if (this.should_reload) location.reload();
+            });
+            socket.on('close', ()=>{
+                this.should_reload = true;
+                setTimeout(this.listen, 500);
+            });
+        }
+    }
+    constructor(url){
+        network_define_property(this, "url", void 0);
+        network_define_property(this, "should_reload", false);
+        this.url = url;
     }
 }
 function get(key) {
@@ -255,57 +498,16 @@ function set(key, value, broadcast = false) {
 }
 function listen(key, cb) {
     document.addEventListener('@corvid/ls-update', (ev)=>{
-        if (ev.detail.key === key || '*' === key) cb({
-            key: ev.detail.key,
-            value: ev.detail.value
-        });
-    });
-}
-function bytesToHuman(bytes, options = {}) {
-    const { useSI = false, decimals = 2, includeUnits = true, targetUnit = null } = options;
-    const unit = useSI ? 1000 : 1024;
-    const units = useSI ? [
-        'B',
-        'kB',
-        'MB',
-        'GB',
-        'TB',
-        'PB',
-        'EB',
-        'ZB',
-        'YB'
-    ] : [
-        'B',
-        'KiB',
-        'MiB',
-        'GiB',
-        'TiB',
-        'PiB',
-        'EiB',
-        'ZiB',
-        'YiB'
-    ];
-    if (null === targetUnit) {
-        let val = parseInt(bytes, 10);
-        if (Math.abs(val) < unit) return `${bytes} B`;
-        let u = 0;
-        while(Math.abs(val) >= unit && u < units.length - 1){
-            val /= unit;
-            u++;
+        if (ev.detail.key === key || '*' === key) {
+            if (cb instanceof dom_el) {
+                if (ev.detail.key === key) cb.content(ev.detail.value);
+                return;
+            }
+            cb({
+                key: ev.detail.key,
+                value: ev.detail.value
+            });
         }
-        if (includeUnits) return `${val.toFixed(decimals)} ${units[u]}`;
-        return `${val.toFixed(decimals)}`;
-    }
-    const targetUnitIndex = units.indexOf(targetUnit);
-    if (-1 === targetUnitIndex) throw new Error(`Invalid unit: ${targetUnit}. Valid units are: ${units.join(', ')}`);
-    let val = parseInt(bytes, 10);
-    for(let i = 0; i < targetUnitIndex; i++)val /= unit;
-    if (includeUnits) return `${val.toFixed(decimals)} ${targetUnit}`;
-    return `${val.toFixed(decimals)}`;
-}
-function genID(len = 15, alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz') {
-    return [
-        ...crypto.getRandomValues(new Uint8Array(len))
-    ].map((value)=>alphabet[Math.floor(value / 255 * alphabet.length)]).join('');
+    });
 }
-export { bytesToHuman, dom_namespaceObject as dom, genID, local_storage_namespaceObject as ls, network_namespaceObject as network, style_namespaceObject as style };
+export { clipboard, dom_namespaceObject as dom, genID, utils_logLevel as logLevel, logger, local_storage_namespaceObject as ls, network_namespaceObject as network, style_namespaceObject as style };

package/dist/local_storage.d.ts

@@ -1,6 +1,7 @@
+import { el } from './dom';
 export declare function get(key: string): any;
 export declare function set(key: string, value: any, broadcast?: boolean): void;
 export declare function listen(key: string, cb: (update: {
     key: string;
     value: any;
-}) => void): void;
+}) => void | el): void;

package/dist/network.d.ts

@@ -1,3 +1,4 @@
+import { logger } from './utils';
 /*** url params ***/
 export declare class params {
     params: URLSearchParams;
@@ -6,6 +7,7 @@ export declare class params {
     toString(): string;
     static render(p: Object): string;
 }
+/*** http request ***/
 export type requestOpts = {
     url?: string;
     type?: 'json';
@@ -15,10 +17,12 @@ export type requestOpts = {
     auth?: string;
     body?: Object;
     success?: number;
+    credentials?: RequestCredentials;
 };
 export declare class request {
     opts: requestOpts;
-    constructor(opts?: requestOpts);
+    log: logger;
+    constructor(opts?: requestOpts, verbose?: boolean);
     auth(token: string): this;
     basicAuth(username: string, password: string): this;
     body(body: Object): this;
@@ -31,3 +35,29 @@ export declare class request {
         };
     }): Promise<any>;
 }
+/*** websocket ***/
+export declare class ws {
+    url: string;
+    ws: WebSocket | null;
+    backoff: number;
+    max_timeout: number;
+    should_reconnect: boolean;
+    is_connected: boolean;
+    recursion_level: number;
+    log: logger;
+    event_listeners: Record<string, Array<(data: any) => void>>;
+    constructor(url: string, verbose?: boolean);
+    setup(): void;
+    send(data: any): void;
+    onMessage(cb: (data: any) => void): void;
+    on(event: string, cb: (data: any) => void): void;
+    close(): void;
+}
+/*** refresh ***/
+export declare class refresh {
+    url: string;
+    should_reload: boolean;
+    constructor(url: string);
+    listen(): void;
+}
+/*** server sent events ***/

package/dist/strings.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts bytes to a human-readable string representation
+ *
+ * @param bytes - The number of bytes to convert
+ * @param options - Optional configuration
+ * @param options.useSI - If true, use SI units (KB, MB, GB) with powers of 1000
+ *                                 If false, use binary units (KiB, MiB, GiB) with powers of 1024
+ * @param options.decimals - Number of decimal places to include (default: 2)
+ * @return Human-readable representation (e.g., "4.2 MB" or "3.7 GiB")
+ */
+export type bytesOptions = {
+    useSI?: boolean;
+    decimals?: number;
+    includeUnits?: boolean;
+    targetUnit?: string;
+};
+export declare function bytesToHuman(bytes: string, options?: bytesOptions): string;
+export declare function toKebab(str: string): string;

package/dist/utils.d.ts

@@ -1,23 +1,6 @@
 /***************
  *    Utils    *
  **************/
-/**
- * Converts bytes to a human-readable string representation
- *
- * @param bytes - The number of bytes to convert
- * @param options - Optional configuration
- * @param options.useSI - If true, use SI units (KB, MB, GB) with powers of 1000
- *                                 If false, use binary units (KiB, MiB, GiB) with powers of 1024
- * @param options.decimals - Number of decimal places to include (default: 2)
- * @return Human-readable representation (e.g., "4.2 MB" or "3.7 GiB")
- */
-export type bytesOptions = {
-    useSI?: boolean;
-    decimals?: number;
-    includeUnits?: boolean;
-    targetUnit?: string;
-};
-export declare function bytesToHuman(bytes: string, options?: bytesOptions): string;
 /**
  * Generates a random id of length len using provided alphabet
  * @param len - The length of the string to generate
@@ -25,3 +8,32 @@ export declare function bytesToHuman(bytes: string, options?: bytesOptions): str
  * @return A new random id
  */
 export declare function genID(len?: number, alphabet?: string): string;
+/**
+ * Clipboard helper because i can't remember the funciton names
+ */
+export declare const clipboard: {
+    copy(text: string): Promise<void>;
+    copyArbitrary(data: any): Promise<void>;
+    read(): Promise<string>;
+    readArbitrary(): Promise<any>;
+    listen(query: string | HTMLElement, cb: (contents: string) => string): void;
+};
+export declare enum logLevel {
+    none = -1,
+    error = 0,
+    warn = 1,
+    info = 2,
+    debug = 3,
+    trace = 4
+}
+export declare class logger {
+    level: logLevel;
+    prefix: string;
+    constructor(level?: logLevel, prefix?: string);
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    trace(...args: any[]): void;
+    log(...args: any[]): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taybart/corvid",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {