@taybart/corvid 0.0.1

package/README.md

@@ -0,0 +1 @@
+# Corvid

package/dist/dom.d.ts

@@ -0,0 +1,39 @@
+/***************
+ *    DOM      *
+ ***************/
+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;
+}
+export declare class el {
+    el: HTMLElement | null;
+    constructor({ id, type, content, }: {
+        id: string;
+        type: string;
+        content?: any;
+    });
+    child(ch: HTMLElement): this;
+    inner(content: any): this;
+    src(url: string): this;
+    style(style: Object | string): this;
+    onClick(cb: (ev: Event) => void): this;
+    listen(event: string, cb: (ev: Event) => void): this;
+}
+export declare class params {
+    params: URLSearchParams;
+    constructor();
+    set(p: Object): this;
+    toString(): string;
+}
+export declare const ls: {
+    get(k: string): string | null;
+    set(k: string, v: any): void;
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * as dom from './dom';
+export * as style from './style';
+export * as utils from './utils';

package/dist/index.js

@@ -0,0 +1,277 @@
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+var dom_namespaceObject = {};
+__webpack_require__.r(dom_namespaceObject);
+__webpack_require__.d(dom_namespaceObject, {
+    btn: ()=>btn,
+    el: ()=>el,
+    form: ()=>dom_form,
+    ls: ()=>ls,
+    params: ()=>params,
+    ready: ()=>ready
+});
+var style_namespaceObject = {};
+__webpack_require__.r(style_namespaceObject);
+__webpack_require__.d(style_namespaceObject, {
+    cssVar: ()=>cssVar,
+    gradient: ()=>gradient,
+    isDarkMode: ()=>isDarkMode,
+    onDarkMode: ()=>onDarkMode,
+    switchTheme: ()=>switchTheme
+});
+var utils_namespaceObject = {};
+__webpack_require__.r(utils_namespaceObject);
+__webpack_require__.d(utils_namespaceObject, {
+    bytesToHuman: ()=>bytesToHuman,
+    genID: ()=>genID,
+    request: ()=>request
+});
+function _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 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 dom_form {
+    byID(id) {
+        this.el = document.getElementById(id);
+        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;
+        null == (_this_el = this.el) || _this_el.appendChild(ch);
+        return this;
+    }
+    inner(content) {
+        if (this.el) this.el.innerHTML = content;
+        return this;
+    }
+    src(url) {
+        if (this.el instanceof HTMLIFrameElement) this.el.src = url;
+        return this;
+    }
+    style(style) {
+        if (this.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};`);
+                this.el.style = s;
+            }
+        }
+        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);
+        return this;
+    }
+    constructor({ id, type, content }){
+        _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 (this.el && content) this.el.innerHTML = content;
+    }
+}
+class params {
+    set(p) {
+        for (let [k, v] of Object.entries(p))this.params.set(k, v);
+        return this;
+    }
+    toString() {
+        return this.params.toString();
+    }
+    constructor(){
+        _define_property(this, "params", void 0);
+        this.params = new URLSearchParams();
+    }
+}
+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);
+}
+function isDarkMode() {
+    return window.matchMedia('(prefers-color-scheme: dark)').matches;
+}
+function onDarkMode(cb) {
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (ev)=>{
+        cb(ev.matches);
+    });
+}
+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})`;
+}
+function utils_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 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 (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('');
+}
+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;
+        const res = await fetch(`${this.opts.url}${path}`, {
+            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 };

package/dist/style.d.ts

@@ -0,0 +1,14 @@
+/***************
+ *    Style    *
+ **************/
+export declare function switchTheme(theme: string): void;
+export declare function cssVar(name: string): string;
+export declare function isDarkMode(): boolean;
+export declare function onDarkMode(cb: (dark: boolean) => void): void;
+export type Color = {
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+};
+export declare function gradient(start: Color, end: Color, value: number): string;

package/dist/utils.d.ts

@@ -0,0 +1,48 @@
+/***************
+ *    Utils    *
+ **************/
+/**
+ * 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
+ *                                 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")
+ */
+export type Options = {
+    useSI?: boolean;
+    decimals?: number;
+    includeUnits?: boolean;
+    targetUnit?: string;
+};
+export declare function bytesToHuman(bytes: string, options?: Options): string;
+/**
+ * Generates a random id of length len using provided alphabet
+ * @param len - The length of the string to generate
+ * @param [alphabet='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'] - The set of characters to use
+ * @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

@@ -0,0 +1,25 @@
+{
+  "name": "@taybart/corvid",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.6.2",
+    "@types/node": "^22.8.1",
+    "typescript": "^5.8.3"
+  }
+}