@taybart/corvid 0.0.3 → 0.0.5

package/dist/dom.d.ts

@@ -1,39 +1,42 @@
-/***************
- *    DOM      *
+/****************
+ *     DOM      *
  ***************/
+/*** window ***/
+/**
+ * onDomContentLoaded
+ */
 export declare function ready(cb: () => void): void;
-export declare class btn {
-    el: Element | null;
-    constructor(id: string, content: string);
-    onClick(cb: (ev: Event) => void): void;
-}
-export declare class form {
-    el: Element | null;
-    constructor(id: string);
-    byID(id: string): this;
-    onChange(cb: (ev: Event) => void): void;
-}
+/*** element ***/
+type elOpts = {
+    query?: string;
+    type?: string;
+    content?: any;
+    parent?: HTMLElement;
+    create?: boolean;
+};
 export declare class el {
     el: HTMLElement | null;
-    constructor({ id, type, content, }: {
-        id: string;
-        type: string;
-        content?: any;
-    });
+    constructor(opts: string | elOpts);
+    /*** get ***/
+    value(): string;
+    /*** set ***/
+    parent(parent: HTMLElement): this;
     child(ch: HTMLElement): this;
-    inner(content: any): this;
+    inner(content: any, { force, text }?: {
+        force?: boolean;
+        text?: boolean;
+    }): this;
     src(url: string): this;
     style(style: Object | string): this;
-    onClick(cb: (ev: Event) => void): this;
     listen(event: string, cb: (ev: Event) => void): this;
+    onClick(cb: (ev: Event) => void): this;
 }
+/*** url params ***/
 export declare class params {
     params: URLSearchParams;
-    constructor();
+    constructor(p?: Object);
     set(p: Object): this;
     toString(): string;
+    static render(p: Object): string;
 }
-export declare const ls: {
-    get(k: string): string | null;
-    set(k: string, v: any): void;
-};
+export {};

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export * as dom from './dom';
 export * as style from './style';
-export * as utils from './utils';
+export * as network from './network';
+export * as ls from './local_storage';
+export * from './utils';

package/dist/index.js

@@ -23,11 +23,8 @@ var __webpack_require__ = {};
 var dom_namespaceObject = {};
 __webpack_require__.r(dom_namespaceObject);
 __webpack_require__.d(dom_namespaceObject, {
-    btn: ()=>btn,
     el: ()=>el,
-    form: ()=>dom_form,
-    ls: ()=>ls,
-    params: ()=>params,
+    params: ()=>dom_params,
     ready: ()=>ready
 });
 var style_namespaceObject = {};
@@ -39,13 +36,18 @@ __webpack_require__.d(style_namespaceObject, {
     onDarkMode: ()=>onDarkMode,
     switchTheme: ()=>switchTheme
 });
-var utils_namespaceObject = {};
-__webpack_require__.r(utils_namespaceObject);
-__webpack_require__.d(utils_namespaceObject, {
-    bytesToHuman: ()=>bytesToHuman,
-    genID: ()=>genID,
+var network_namespaceObject = {};
+__webpack_require__.r(network_namespaceObject);
+__webpack_require__.d(network_namespaceObject, {
     request: ()=>request
 });
+var local_storage_namespaceObject = {};
+__webpack_require__.r(local_storage_namespaceObject);
+__webpack_require__.d(local_storage_namespaceObject, {
+    get: ()=>get,
+    listen: ()=>listen,
+    set: ()=>set
+});
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -59,47 +61,32 @@ function _define_property(obj, key, value) {
 function ready(cb) {
     window.addEventListener('DOMContentLoaded', cb);
 }
-class btn {
-    onClick(cb) {
-        var _this_el;
-        null == (_this_el = this.el) || _this_el.addEventListener('click', cb);
-    }
-    constructor(id, content){
-        _define_property(this, "el", void 0);
-        this.el = null;
-        if (id) {
-            this.el = document.getElementById(id);
-            if (this.el && content) this.el.innerHTML = content;
-        }
+class el {
+    value() {
+        if (this.el && this.el instanceof HTMLInputElement) return this.el.value;
+        return '';
     }
-}
-class dom_form {
-    byID(id) {
-        this.el = document.getElementById(id);
+    parent(parent) {
+        if (!this.el) throw new Error('no element');
+        parent.appendChild(this.el);
         return this;
     }
-    onChange(cb) {
-        var _this_el;
-        null == (_this_el = this.el) || _this_el.addEventListener('change', cb);
-    }
-    constructor(id){
-        _define_property(this, "el", void 0);
-        this.el = null;
-        if (id) this.el = document.getElementById(id);
-    }
-}
-class el {
     child(ch) {
         var _this_el;
+        if (!this.el) throw new Error('no element');
         null == (_this_el = this.el) || _this_el.appendChild(ch);
         return this;
     }
-    inner(content) {
-        if (this.el) this.el.innerHTML = content;
+    inner(content, { force = false, text = false } = {}) {
+        if (!this.el) throw new Error('no element');
+        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;
+        else this.el.innerHTML = content;
         return this;
     }
     src(url) {
-        if (this.el instanceof HTMLIFrameElement) this.el.src = url;
+        if (this.el instanceof HTMLIFrameElement || this.el instanceof HTMLImageElement) this.el.src = url;
         return this;
     }
     style(style) {
@@ -113,25 +100,31 @@ class el {
         }
         return this;
     }
-    onClick(cb) {
-        var _this_el;
-        null == (_this_el = this.el) || _this_el.addEventListener('click', cb);
-        return this;
-    }
     listen(event, cb) {
-        var _this_el;
-        null == (_this_el = this.el) || _this_el.addEventListener(event, cb);
+        if (!this.el) throw new Error('no element');
+        this.el.addEventListener(event, cb);
         return this;
     }
-    constructor({ id, type, content }){
+    onClick(cb) {
+        return this.listen('click', cb);
+    }
+    constructor(opts){
         _define_property(this, "el", void 0);
-        if (id) this.el = document.getElementById(id);
-        else if (type) this.el = document.createElement(type);
-        else throw new Error('no id or type provided');
+        if ('string' == typeof opts) {
+            this.el = document.querySelector(opts);
+            return;
+        }
+        const { query, type, content, parent, create } = opts;
+        if (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);
     }
 }
-class params {
+class dom_params {
     set(p) {
         for (let [k, v] of Object.entries(p))this.params.set(k, v);
         return this;
@@ -139,22 +132,18 @@ class params {
     toString() {
         return this.params.toString();
     }
-    constructor(){
+    static render(p) {
+        const params = new URLSearchParams();
+        if (p) for (let [k, v] of Object.entries(p))params.set(k, v);
+        return params.toString();
+    }
+    constructor(p){
         _define_property(this, "params", void 0);
         this.params = new URLSearchParams();
+        if (p) for (let [k, v] of Object.entries(p))this.params.set(k, v);
+        return this;
     }
 }
-const ls = {
-    get (k) {
-        return localStorage.getItem(k);
-    },
-    set (k, v) {
-        localStorage.setItem(k, v);
-    }
-};
-function switchTheme(theme) {
-    document.documentElement.setAttribute('data-theme', theme);
-}
 function cssVar(name) {
     const style = window.getComputedStyle(document.body);
     return style.getPropertyValue(name);
@@ -167,15 +156,17 @@ function onDarkMode(cb) {
         cb(ev.matches);
     });
 }
+function switchTheme(theme) {
+    document.documentElement.setAttribute('data-theme', theme);
+}
 function gradient(start, end, value) {
     value = Math.max(0, Math.min(100, value));
     const red = Math.round(start.red + (end.red - start.red) * value / 100);
     const green = Math.round(start.green + (end.green - start.green) * value / 100);
     const blue = Math.round(start.blue + (end.blue - start.blue) * value / 100);
-    const alpha = Math.round(start.alpha + (end.alpha - start.alpha) * value / 100);
-    return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
+    return `rgb(${red}, ${green}, ${blue})`;
 }
-function utils_define_property(obj, key, value) {
+function network_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
         enumerable: true,
@@ -185,6 +176,74 @@ function utils_define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
+class request {
+    auth(token) {
+        this.opts.headers.Authorization = `Bearer ${token}`;
+        return this;
+    }
+    basicAuth(username, password) {
+        this.opts.headers.Authorization = 'Basic ' + btoa(username + ':' + password);
+        return this;
+    }
+    body(body) {
+        this.opts.body = body;
+        return this;
+    }
+    async do({ path, overrideBody, overrideSuccess } = {}) {
+        if (this.opts.auth) this.opts.headers.Authorization = `Bearer ${this.opts.auth}`;
+        const body = overrideBody || this.opts.body;
+        let url = this.opts.url;
+        if (path) url = `${this.opts.url}${path}`;
+        const res = await fetch(url, {
+            method: this.opts.method,
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                ...this.opts.headers
+            },
+            body: JSON.stringify(body)
+        });
+        const success = overrideSuccess || this.opts.success;
+        if (res.status !== success) {
+            const body = await res.json();
+            throw new Error(`bad response ${res.status} !== ${this.opts.success}, body: ${body}`);
+        }
+        return await res.json();
+    }
+    constructor(opts){
+        network_define_property(this, "opts", void 0);
+        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 = {};
+    }
+}
+function get(key) {
+    return localStorage.getItem(key);
+}
+function set(key, value, broadcast = false) {
+    const prev = get(key);
+    if (prev !== value || broadcast) {
+        const event = new CustomEvent('@corvid/ls-update', {
+            detail: {
+                key,
+                value
+            }
+        });
+        document.dispatchEvent(event);
+    }
+    localStorage.setItem(key, value);
+}
+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;
@@ -232,48 +291,4 @@ function genID(len = 15, alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg
         ...crypto.getRandomValues(new Uint8Array(len))
     ].map((value)=>alphabet[Math.floor(value / 255 * alphabet.length)]).join('');
 }
-class request {
-    auth(token) {
-        this.opts.headers.Authorization = `Bearer ${token}`;
-        return this;
-    }
-    basicAuth(username, password) {
-        this.opts.headers.Authorization = 'Basic ' + btoa(username + ':' + password);
-        return this;
-    }
-    body(body) {
-        this.opts.body = body;
-        return this;
-    }
-    async do({ path, overrideBody, overrideSuccess } = {}) {
-        if (this.opts.auth) this.opts.headers.Authorization = `Bearer ${this.opts.auth}`;
-        const body = overrideBody || this.opts.body;
-        let url = this.opts.url;
-        if (path) url = `${this.opts.url}${path}`;
-        const res = await fetch(url, {
-            method: this.opts.method,
-            headers: {
-                accept: 'application/json',
-                'content-type': 'application/json',
-                ...this.opts.headers
-            },
-            body: JSON.stringify(body)
-        });
-        const success = overrideSuccess || this.opts.success;
-        if (res.status !== success) {
-            const body = await res.json();
-            throw new Error(`bad response ${res.status} !== ${this.opts.success}, body: ${body}`);
-        }
-        return await res.json();
-    }
-    constructor(opts){
-        utils_define_property(this, "opts", void 0);
-        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 = {};
-    }
-}
-export { dom_namespaceObject as dom, style_namespaceObject as style, utils_namespaceObject as utils };
+export { bytesToHuman, dom_namespaceObject as dom, genID, local_storage_namespaceObject as ls, network_namespaceObject as network, style_namespaceObject as style };

package/dist/local_storage.d.ts

@@ -0,0 +1,6 @@
+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;

package/dist/network.d.ts

@@ -0,0 +1,21 @@
+export type requestOpts = {
+    url: string;
+    type: 'json';
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers: Record<string, string>;
+    auth: string;
+    body: Object;
+    success: number;
+};
+export declare class request {
+    opts: requestOpts;
+    constructor(opts: requestOpts);
+    auth(token: string): this;
+    basicAuth(username: string, password: string): this;
+    body(body: Object): this;
+    do({ path, overrideBody, overrideSuccess, }?: {
+        path?: string;
+        overrideBody?: Object;
+        overrideSuccess?: number;
+    }): Promise<any>;
+}

package/dist/style.d.ts

@@ -1,14 +1,31 @@
 /***************
  *    Style    *
  **************/
-export declare function switchTheme(theme: string): void;
 export declare function cssVar(name: string): string;
+/**
+ * Check if the current theme is dark
+ */
 export declare function isDarkMode(): boolean;
-export declare function onDarkMode(cb: (dark: boolean) => void): void;
-export type Color = {
+/**
+ * Listen for changes in the dark mode preference
+ * @param cb - Callback function when theme changes
+ */
+export declare function onDarkMode(cb: (isDark: boolean) => void): void;
+/**
+ * Switch between light and dark theme
+ * @param theme - 'light' or 'dark'
+ */
+export declare function switchTheme(theme: string): void;
+/**
+ * Calculate a color gradient
+ * @param start - The starting color
+ * @param end - The ending color
+ * @param value - The value to interpolate between the start and end colors 0 <= value <= 100
+ * @return rgb string
+ */
+export type color = {
     red: number;
     green: number;
     blue: number;
-    alpha: number;
 };
-export declare function gradient(start: Color, end: Color, value: number): string;
+export declare function gradient(start: color, end: color, value: number): string;

package/dist/utils.d.ts

@@ -4,20 +4,20 @@
 /**
  * Converts bytes to a human-readable string representation
  *
- * @param {number} bytes - The number of bytes to convert
- * @param {Object} options - Optional configuration
- * @param {boolean} options.useSI - If true, use SI units (KB, MB, GB) with powers of 1000
+ * @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 {number} options.decimals - Number of decimal places to include (default: 2)
- * @return {string} Human-readable representation (e.g., "4.2 MB" or "3.7 GiB")
+ * @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 Options = {
+export type bytesOptions = {
     useSI?: boolean;
     decimals?: number;
     includeUnits?: boolean;
     targetUnit?: string;
 };
-export declare function bytesToHuman(bytes: string, options?: Options): 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,24 +25,3 @@ export declare function bytesToHuman(bytes: string, options?: Options): string;
  * @return A new random id
  */
 export declare function genID(len?: number, alphabet?: string): string;
-export type RequestOptions = {
-    url: string;
-    type: 'json';
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
-    headers: Record<string, string>;
-    auth: string;
-    body: Object;
-    success: number;
-};
-export declare class request {
-    opts: RequestOptions;
-    constructor(opts: RequestOptions);
-    auth(token: string): this;
-    basicAuth(username: string, password: string): this;
-    body(body: Object): this;
-    do({ path, overrideBody, overrideSuccess, }?: {
-        path?: string;
-        overrideBody?: Object;
-        overrideSuccess?: number;
-    }): Promise<any>;
-}

package/package.json

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