@briklab/lib 1.0.1 → 1.0.9

package/dist/cli-john/index.d.ts

@@ -52,6 +52,7 @@
  *
  * @module cli-john
  */
+import InlineStyle, { StyleSheet } from "../stylesheet/index.js";
 /**
  * # CLI
  * @classdesc The main class for **CLI**.
@@ -87,7 +88,7 @@ export declare class CLI {
 }
 export declare namespace CLI {
     const ValidEvents: readonly ["command"];
-    type ValidEvent = typeof ValidEvents[number];
+    type ValidEvent = (typeof ValidEvents)[number];
     /**
      * ## CLI.Command
      * A command in a CLI Command
@@ -127,9 +128,24 @@ export declare namespace CLI.Command {
         get name(): string;
     }
 }
-/**
- * Will be implemented in v1.2.0
- * @experimental v1.2.0
- */
-export declare namespace Utilities {
+declare class UtilitiesClass {
+    styleSheet: StyleSheet;
+    tags: Record<string, {
+        tag: string;
+        showErrorInTag: boolean;
+        paddingLeft: number;
+        paddingRight: number;
+        styleName: string;
+    }>;
+    constructor();
+    /** Add a new tag */
+    addTag(name: string, config?: Partial<(typeof this.tags)["error"]>): this;
+    /** Set style for a tag */
+    setTagStyle(tagName: string, style: InlineStyle): this;
+    log(tagName: string, message: string): void;
+    error(msg: string): this;
+    warning(msg: string): this;
+    info(msg: string): this;
 }
+export declare const Utilities: UtilitiesClass;
+export {};

package/dist/cli-john/index.js

@@ -64,7 +64,10 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _CLI_instances, _CLI_commands, _CLI_onCmdFunctions, _CLI_figureOutCommand, _CLI_process, _CLI_ErrorClass, _CLI_createErr, _CLI_createWarn;
-import JSTC from "../jstc";
+// -------------------------------------------------------------------------------------------------------
+//#region Defination of custom JSTC handler
+import JSTC from "../jstc/index.js";
+import InlineStyle, { StyleSheet } from "../stylesheet/index.js";
 JSTC.addCustomHandler("NodeJS Process", (p) => {
     return (p &&
         typeof p === "object" &&
@@ -210,9 +213,7 @@ class CLIErrors extends Error {
 }
 (function (CLI) {
     var _Command_instances, _Command_name, _Command_createWarn, _Command_options;
-    CLI.ValidEvents = [
-        "command"
-    ];
+    CLI.ValidEvents = ["command"];
     /**
      * ## CLI.Command
      * A command in a CLI Command
@@ -302,6 +303,146 @@ class CLIErrors extends Error {
 })(CLI || (CLI = {}));
 //#endregion
 // -------------------------------------------------------------------------------------------------------
+//#region CLI Utilities
+JSTC.addCustomHandler("Utilities Tag Config", (p) => {
+    return (p &&
+        typeof p === "object" &&
+        typeof p.tag === "string" &&
+        typeof p.showErrorInTag === "boolean" &&
+        typeof p.paddingLeft === "number" &&
+        typeof p.paddingRight === "number" &&
+        (typeof p.styleName === "string" || p.styleName === undefined));
+});
+class UtilitiesClass {
+    constructor() {
+        this.styleSheet = new StyleSheet();
+        this.tags = {};
+        this.addTag("error", {
+            tag: "ERROR",
+            showErrorInTag: false,
+            paddingLeft: 1,
+            paddingRight: 1,
+        });
+        this.addTag("warning", {
+            tag: "WARNING",
+            showErrorInTag: true,
+            paddingLeft: 1,
+            paddingRight: 1,
+        });
+        this.addTag("info", {
+            tag: "INFO",
+            showErrorInTag: true,
+            paddingLeft: 1,
+            paddingRight: 1,
+        });
+        this.setTagStyle("error", new InlineStyle({ color: "red", fontWeight: "bold" }));
+        this.setTagStyle("warning", new InlineStyle({ color: "orange", fontWeight: "bold" }));
+        this.setTagStyle("info", new InlineStyle({ color: "blue" }));
+    }
+    /** Add a new tag */
+    addTag(name, config = {}) {
+        if (!JSTC.for([name, config]).check(["string", "object"])) {
+            console.warn(`[UtilitiesClass.addTag] @briklab/lib/cli-john: Invalid Arguments!
+        Hint: The first argument must be a string, and the second argument must be a object.
+        Using String(argument1) and {} as fallback.`);
+            name = String(name);
+            config = {};
+        }
+        const fullConfig = {
+            tag: name.toUpperCase(),
+            showErrorInTag: false,
+            paddingLeft: 0,
+            paddingRight: 0,
+            styleName: "",
+            ...config,
+        };
+        if (!JSTC.for([fullConfig]).check(["Utilities Tag Config"])) {
+            console.warn(`[UtilitiesClass.addTag] @briklab/lib/cli-john: Invalid tag config passed for "${name}"
+        Hint: The config must be in format {tag?: string, showErrorInTag?:boolean, paddingLeft?:number, paddingRight?:number, styleName?:string}`);
+            console.warn(fullConfig);
+            return this;
+        }
+        this.tags[name] = fullConfig;
+        return this;
+    }
+    /** Set style for a tag */
+    setTagStyle(tagName, style) {
+        if (typeof tagName !== "string" || !(style instanceof InlineStyle)) {
+            console.warn(`[UtilitiesClass.setTagStyle] @briklab/lib/cli-john: Invalid arguments!
+        Hint: The first argument must be a string and the second argument must be a instance of InlineStyle
+        Using String(firstArgument) and new InlineStyle({}) as fallback`);
+            tagName = String(tagName);
+            style = new InlineStyle({});
+        }
+        if (!this.tags[tagName]) {
+            console.warn(`[UtilitiesClass.setTagStyle] @briklab/lib/cli-john: Tag "${tagName}" does not exist! 
+        Hint: Use a valid tag that you have defined or use "error"|"warn"|"info"`);
+            return this;
+        }
+        const styleName = `${tagName} Tag Color`;
+        this.styleSheet.set(styleName, style);
+        this.tags[tagName].styleName = styleName;
+        return this;
+    }
+    log(tagName, message) {
+        if (!JSTC.for([tagName, message]).check(["string", "string"])) {
+            console.warn(`[UtilitiesClass.log] @briklab/lib/cli-john: Invalid Arguments!
+        Hint: The first argument must be a string and the second argument must be a string
+        Using String(argument1) and String(argument2) as fallback`);
+            tagName = String(tagName);
+            message = String(message);
+        }
+        const tag = this.tags[tagName];
+        if (!tag) {
+            console.warn(`[UtilitiesClass.log] @briklab/lib/cli-john: Tag "${tagName}" does not exist! 
+        Hint: Use a valid tag that you have defined or use "error"|"warn"|"info"`);
+            console.log(message);
+            return;
+        }
+        const style = this.styleSheet.get(tag.styleName)?.text ?? "";
+        const leftPad = " ".repeat(tag.paddingLeft);
+        const rightPad = " ".repeat(tag.paddingRight);
+        if (tag.showErrorInTag) {
+            console.log(`[%c${leftPad}${tag.tag}${rightPad}%c]: ${message}`, style);
+        }
+        else {
+            console.log(`%c[${leftPad}${tag.tag}${rightPad}]%c: ${message}`, style);
+        }
+    }
+    error(msg) {
+        if (typeof msg !== "string") {
+            console.warn(`[UtilitiesClass.error] Invalid First Argument!
+      Hint: The first argument must be a string.
+      Using String(firstArgument) as fallback`);
+            msg = String(msg);
+        }
+        this.log("error", msg);
+        return this;
+    }
+    warning(msg) {
+        if (typeof msg !== "string") {
+            console.warn(`[UtilitiesClass.warning] Invalid First Argument!
+      Hint: The first argument must be a string.
+      Using String(firstArgument) as fallback`);
+            msg = String(msg);
+        }
+        this.log("warning", msg);
+        return this;
+    }
+    info(msg) {
+        if (typeof msg !== "string") {
+            console.warn(`[UtilitiesClass.info] Invalid First Argument!
+      Hint: The first argument must be a string.
+      Using String(firstArgument) as fallback`);
+            msg = String(msg);
+        }
+        this.log("info", msg);
+        return this;
+    }
+}
+export const Utilities = new UtilitiesClass();
+//#endregion
+// -------------------------------------------------------------------------------------------------------
 //#region TODO
 // TODO: Wire Options to Commands
 // TODO: Create metadata getter-s in both commands and options

package/dist/color/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Easy way to use colors
+ */
+type ColorInput = string | {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+} | {
+    h: number;
+    s: number;
+    l: number;
+    a?: number;
+};
+export default class Color {
+    #private;
+    private r;
+    private g;
+    private b;
+    private a;
+    constructor(input: ColorInput);
+    hex(): string;
+    rgb(): string;
+    rgba(): string;
+    hsl(): string;
+    hsla(): string;
+    css(): string;
+}
+export {};

package/dist/color/index.js

@@ -0,0 +1,153 @@
+/**
+ * Easy way to use colors
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Color_instances, _Color_clamp, _Color_toHex, _Color_parseString, _Color_hslToRgb, _Color_rgbToHsl;
+const NAMED_COLORS = {
+    red: "#ff0000",
+    blue: "#0000ff",
+    green: "#00ff00",
+    yellow: "#ffff00",
+    orange: "#ffa500",
+    black: "#000000",
+    white: "#ffffff",
+    gray: "#808080",
+};
+class Color {
+    constructor(input) {
+        _Color_instances.add(this);
+        this.r = 0;
+        this.g = 0;
+        this.b = 0;
+        this.a = 1;
+        if (typeof input === "string") {
+            __classPrivateFieldGet(this, _Color_instances, "m", _Color_parseString).call(this, input);
+        }
+        else if ("r" in input && "g" in input && "b" in input) {
+            this.r = __classPrivateFieldGet(this, _Color_instances, "m", _Color_clamp).call(this, input.r);
+            this.g = __classPrivateFieldGet(this, _Color_instances, "m", _Color_clamp).call(this, input.g);
+            this.b = __classPrivateFieldGet(this, _Color_instances, "m", _Color_clamp).call(this, input.b);
+            this.a = input.a ?? 1;
+        }
+        else if ("h" in input && "s" in input && "l" in input) {
+            const { r, g, b } = __classPrivateFieldGet(this, _Color_instances, "m", _Color_hslToRgb).call(this, input.h, input.s, input.l);
+            this.r = r;
+            this.g = g;
+            this.b = b;
+            this.a = input.a ?? 1;
+        }
+        else {
+            console.warn(`[Color.constructor] Invalid first argument!
+        Hint: The first argument must be a valid color array
+        Using black as fallback.`);
+        }
+    }
+    // -----------------------
+    // Public Methods
+    // -----------------------
+    hex() {
+        return `#${__classPrivateFieldGet(this, _Color_instances, "m", _Color_toHex).call(this, this.r)}${__classPrivateFieldGet(this, _Color_instances, "m", _Color_toHex).call(this, this.g)}${__classPrivateFieldGet(this, _Color_instances, "m", _Color_toHex).call(this, this.b)}`;
+    }
+    rgb() {
+        return `rgb(${this.r}, ${this.g}, ${this.b})`;
+    }
+    rgba() {
+        return `rgba(${this.r}, ${this.g}, ${this.b}, ${this.a})`;
+    }
+    hsl() {
+        const { h, s, l } = __classPrivateFieldGet(this, _Color_instances, "m", _Color_rgbToHsl).call(this, this.r, this.g, this.b);
+        return `hsl(${h}, ${s}%, ${l}%)`;
+    }
+    hsla() {
+        const { h, s, l } = __classPrivateFieldGet(this, _Color_instances, "m", _Color_rgbToHsl).call(this, this.r, this.g, this.b);
+        return `hsla(${h}, ${s}%, ${l}%, ${this.a})`;
+    }
+    css() {
+        return this.a === 1 ? this.hex() : this.rgba();
+    }
+}
+_Color_instances = new WeakSet(), _Color_clamp = function _Color_clamp(value) {
+    return Math.max(0, Math.min(255, value));
+}, _Color_toHex = function _Color_toHex(value) {
+    return value.toString(16).padStart(2, "0");
+}, _Color_parseString = function _Color_parseString(str) {
+    str = str.trim().toLowerCase();
+    if (NAMED_COLORS[str]) {
+        str = NAMED_COLORS[str];
+    }
+    if (str.startsWith("#")) {
+        const hex = str.slice(1);
+        if (hex.length === 3) {
+            this.r = parseInt(hex[0] + hex[0], 16);
+            this.g = parseInt(hex[1] + hex[1], 16);
+            this.b = parseInt(hex[2] + hex[2], 16);
+        }
+        else if (hex.length === 6) {
+            this.r = parseInt(hex.slice(0, 2), 16);
+            this.g = parseInt(hex.slice(2, 4), 16);
+            this.b = parseInt(hex.slice(4, 6), 16);
+        }
+        else {
+            console.warn(`[Color class] @briklab/lib/color: Invalid hex! 
+            Hint: You must pass a valid hex color string!
+            Using black as fallback.`);
+        }
+    }
+    else if (str.startsWith("rgb")) {
+        const vals = str.match(/[\d.]+/g)?.map(Number);
+        if (vals && vals.length >= 3) {
+            [this.r, this.g, this.b] = vals;
+            this.a = vals[3] ?? 1;
+        }
+    }
+    else if (str.startsWith("hsl")) {
+        const vals = str.match(/[\d.]+/g)?.map(Number);
+        if (vals && vals.length >= 3) {
+            const { r, g, b } = __classPrivateFieldGet(this, _Color_instances, "m", _Color_hslToRgb).call(this, vals[0], vals[1], vals[2]);
+            this.r = r;
+            this.g = g;
+            this.b = b;
+            this.a = vals[3] ?? 1;
+        }
+    }
+    else {
+        console.warn(`[Color class] @briklab/lib/color: Unknown color string "${str}"! 
+        Hint: The argument must be a valid color string!
+        Using black as fallback.`);
+    }
+}, _Color_hslToRgb = function _Color_hslToRgb(h, s, l) {
+    s /= 100;
+    l /= 100;
+    const k = (n) => (n + h / 30) % 12;
+    const a = s * Math.min(l, 1 - l);
+    const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+    return { r: Math.round(f(0) * 255), g: Math.round(f(8) * 255), b: Math.round(f(4) * 255) };
+}, _Color_rgbToHsl = function _Color_rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h = 0, s = 0, l = (max + min) / 2;
+    if (max !== min) {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+        h *= 60;
+    }
+    return { h: Math.round(h), s: Math.round(s * 100), l: Math.round(l * 100) };
+};
+export default Color;

package/dist/jstc/index.d.ts

@@ -1,4 +1,5 @@
 /**
+ * # JSTC
  * @packageDocumentation
  * Runtime JS Type Checker
  * @module JSTC

package/dist/jstc/index.js

@@ -1,4 +1,5 @@
 /**
+ * # JSTC
  * @packageDocumentation
  * Runtime JS Type Checker
  * @module JSTC
@@ -21,8 +22,20 @@ export class JSTypeChecker {
      * @param {unknown[]} args
      */
     for(args) {
+        if (!Array.isArray(args)) {
+            console.warn(`[JSTC.for] @briklab/lib/jstc: Invalid first argument!
+        Hint: The first argument must be a array.
+        Using [givenValue] as fallback`);
+            args = [args];
+        }
         return {
             check: (types) => {
+                if (!Array.isArray(types)) {
+                    console.warn(`[JSTC.for().check] @briklab/lib/jstc: Invalid first argument!
+            Hint: The first argument must be a valid array!
+            Using [givenValue] as fallback`);
+                    types = [types];
+                }
                 if (args.length < types.length)
                     return false;
                 for (let i = 0; i < types.length; i++) {
@@ -61,6 +74,13 @@ export class JSTypeChecker {
         };
     }
     addCustomHandler(name, handler) {
+        if (!(typeof name === "string" && typeof handler === "function")) {
+            console.warn(`[JSTC.addCustomHandler] @briklab/lib/jstc: Invalid Arguments!
+        Hint: The first argument must be a string, and the second argument must be a function
+        Using String(argument1) and ()=>false as fallbacks`);
+            name = String(name);
+            handler = () => false;
+        }
         __classPrivateFieldGet(this, _JSTypeChecker___CustomHandler, "f")[name] = handler;
     }
 }

package/dist/stylesheet/index.d.ts

@@ -1,5 +1,51 @@
 /**
- * SOON
- * @experimental v1.1.0
+ * # @briklab/lib/stylesheet
+ * Create inline styles in JS/TS
  */
-export {};
+/**
+ * # InlineStyle
+ * @classdesc Create a CSS Inline style.
+ * @class
+ */
+export default class InlineStyle {
+    #private;
+    /**
+     * ## constructor
+     * construct a InlineStyle
+     */
+    constructor(styleObject: {
+        [key: string]: string;
+    });
+    generate(): string;
+    get text(): string;
+    addStyleWithObject(styleObject: object): this;
+    addStyleWithInlineCSS(inlineCSS: string): this;
+    removeStyle(styles: string[] | string): this | undefined;
+    applyTo(element: HTMLElement): this;
+}
+export declare class StyleSheet {
+    #private;
+    constructor();
+    /**
+     * Add or update a rule in the stylesheet.
+     * @param name The rule name or selector (string).
+     * @param style An InlineStyle instance.
+     */
+    set(name: string, style: InlineStyle): this;
+    /**
+     * Get a rule by name.
+     */
+    get(name: string): InlineStyle | undefined;
+    /**
+     * Remove a rule by name.
+     */
+    remove(name: string): this;
+    /**
+     * Generate CSS text for the whole stylesheet.
+     */
+    generate(): string;
+    /**
+     * Export as a string for inline style usage or injection.
+     */
+    toString(): string;
+}

package/dist/stylesheet/index.js

@@ -1 +1,186 @@
-export {};
+/**
+ * # @briklab/lib/stylesheet
+ * Create inline styles in JS/TS
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _InlineStyle_instances, _InlineStyle_cssStyleDec, _InlineStyle_convertFieldToHyphenCase, _InlineStyle_convertKeysToValidCSS, _InlineStyle_styleObject, _StyleSheet_styles;
+import JSTC from "../jstc/index";
+import { CSSStyleDeclaration as UUIII } from "cssom";
+/**
+ * # InlineStyle
+ * @classdesc Create a CSS Inline style.
+ * @class
+ */
+class InlineStyle {
+    /**
+     * ## constructor
+     * construct a InlineStyle
+     */
+    constructor(styleObject) {
+        _InlineStyle_instances.add(this);
+        _InlineStyle_cssStyleDec.set(this, void 0);
+        _InlineStyle_styleObject.set(this, void 0);
+        if (!JSTC.for([styleObject]).check(["object|undefined"])) {
+            console.warn(`[InlineStyle class] @briklab/lib/stylesheet: Invalid first argument!
+            Hint: The first argument must be a valid style object or not be given!
+            Using {"imeMode":givenValue} as fallback`);
+            styleObject = { imeMode: `${styleObject}` };
+        }
+        __classPrivateFieldSet(this, _InlineStyle_styleObject, styleObject, "f");
+        __classPrivateFieldSet(this, _InlineStyle_cssStyleDec, new UUIII(), "f");
+    }
+    generate() {
+        let a = __classPrivateFieldGet(this, _InlineStyle_cssStyleDec, "f");
+        let b = __classPrivateFieldGet(this, _InlineStyle_styleObject, "f");
+        let c = Object.keys(b);
+        let d = Object.values(b);
+        for (let i = 0; i < c.length; i++) {
+            let e = c[i];
+            let f = d[i];
+            a.setProperty(e, f);
+        }
+        return a.cssText;
+    }
+    get text() {
+        return this.generate();
+    }
+    addStyleWithObject(styleObject) {
+        if (!JSTC.for([styleObject]).check(["object"])) {
+            console.warn(`[InlineStyle.addStyleWithObject] @briklab/lib/stylesheet: Invalid first argument!
+            Hint: The first argument must be a valid style object or not be given!
+            Using {"imeMode":givenValue} as fallback`);
+            styleObject = { imeMode: styleObject };
+        }
+        __classPrivateFieldSet(this, _InlineStyle_styleObject, { ...__classPrivateFieldGet(this, _InlineStyle_styleObject, "f"), ...styleObject }, "f");
+        this.generate();
+        return this;
+    }
+    addStyleWithInlineCSS(inlineCSS) {
+        if (!JSTC.for([inlineCSS]).check(["string"])) {
+            console.warn(`[InlineStyle.addStyleWithInlineCSS] @briklab/lib/stylesheet: Invalid first argument!
+        Hint: The first argument must be a valid inline css string!
+        Returned with no operations.`);
+            return this;
+        }
+        let s = new UUIII();
+        s.cssText = __classPrivateFieldGet(this, _InlineStyle_instances, "m", _InlineStyle_convertKeysToValidCSS).call(this, inlineCSS);
+        let o = {};
+        for (let i = 0; i < s.length; i++) {
+            const a = s[i];
+            const v = s.getPropertyValue(a);
+            o[a] = v;
+        }
+        this.addStyleWithObject(o);
+        return this;
+    }
+    removeStyle(styles) {
+        if (!JSTC.for([styles]).check(["string[]|string"])) {
+            console.warn(`[InlineStyle.removeStyle] @briklab/lib/stylesheet: Invalid first argument!
+        Hint: The first argument must be a array of valid css properties or a single valid css property [accepts any string though]
+        Returned with no operations.`);
+            return this;
+        }
+        if (typeof styles === "string") {
+            styles = [styles];
+        }
+        for (let i = 0; i < styles.length; i++) {
+            let a = styles[i];
+            delete __classPrivateFieldGet(this, _InlineStyle_styleObject, "f")[a];
+        }
+    }
+    applyTo(element) {
+        element.style.cssText = this.generate();
+        return this;
+    }
+}
+_InlineStyle_cssStyleDec = new WeakMap(), _InlineStyle_styleObject = new WeakMap(), _InlineStyle_instances = new WeakSet(), _InlineStyle_convertFieldToHyphenCase = function _InlineStyle_convertFieldToHyphenCase(string) {
+    return string.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`);
+}, _InlineStyle_convertKeysToValidCSS = function _InlineStyle_convertKeysToValidCSS(string) {
+    let a = string.split(";");
+    let c = "";
+    for (let i = 0; i < a.length; i++) {
+        let b = a[i];
+        let [k, v] = b.split(":");
+        k = k.trim();
+        v = v.trim();
+        c += `${__classPrivateFieldGet(this, _InlineStyle_instances, "m", _InlineStyle_convertFieldToHyphenCase).call(this, k)}:${v};`;
+    }
+    return c;
+};
+export default InlineStyle;
+export class StyleSheet {
+    constructor() {
+        _StyleSheet_styles.set(this, void 0);
+        __classPrivateFieldSet(this, _StyleSheet_styles, {}, "f");
+    }
+    /**
+     * Add or update a rule in the stylesheet.
+     * @param name The rule name or selector (string).
+     * @param style An InlineStyle instance.
+     */
+    set(name, style) {
+        if (!JSTC.for([name, style]).check(["string", "object"])) {
+            console.warn(`[StyleSheet.set] @briklab/lib/stylesheet: Invalid arguments! ` +
+                `Name must be string, style must be InlineStyle instance. Received: name=${name}, style=${style}`);
+            return this;
+        }
+        if (!(style instanceof InlineStyle)) {
+            console.warn(`[StyleSheet.set] @briklab/lib/stylesheet: Provided style is not an InlineStyle instance! ` +
+                `Received: ${style}`);
+            return this;
+        }
+        __classPrivateFieldGet(this, _StyleSheet_styles, "f")[name] = style;
+        return this;
+    }
+    /**
+     * Get a rule by name.
+     */
+    get(name) {
+        if (!JSTC.for([name]).check(["string"])) {
+            console.warn(`[StyleSheet.get] @briklab/lib/stylesheet: Invalid argument! Name must be a string. Received: ${name}`);
+            return undefined;
+        }
+        return __classPrivateFieldGet(this, _StyleSheet_styles, "f")[name];
+    }
+    /**
+     * Remove a rule by name.
+     */
+    remove(name) {
+        if (!JSTC.for([name]).check(["string"])) {
+            console.warn(`[StyleSheet.remove] @briklab/lib/stylesheet: Invalid argument! Name must be a string. Received: ${name}`);
+            return this;
+        }
+        delete __classPrivateFieldGet(this, _StyleSheet_styles, "f")[name];
+        return this;
+    }
+    /**
+     * Generate CSS text for the whole stylesheet.
+     */
+    generate() {
+        let css = "";
+        for (const key in __classPrivateFieldGet(this, _StyleSheet_styles, "f")) {
+            const style = __classPrivateFieldGet(this, _StyleSheet_styles, "f")[key];
+            if (style) {
+                css += `${key} { ${style.text} }\n`;
+            }
+        }
+        return css.trim();
+    }
+    /**
+     * Export as a string for inline style usage or injection.
+     */
+    toString() {
+        return this.generate();
+    }
+}
+_StyleSheet_styles = new WeakMap();

package/package.json

@@ -18,7 +18,13 @@
   "keywords": [
     "helpers",
     "typescript",
-    "types"
+    "types",
+    "cli",
+    "stylesheet",
+    "javascript",
+    "js",
+    "command",
+    "style"
   ],
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -28,8 +34,9 @@
   "repository": {
     "url": "https://github.com/EkaanshPC/briklab-stdlib"
   },
-  "version": "1.0.1",
+  "version": "1.0.9",
   "devDependencies": {
+    "@types/cssom": "^0.4.3",
     "@types/node": "^25.1.0",
     "typescript": "^5.9.3"
   },
@@ -45,8 +52,19 @@
     "./jstc": {
       "import": "./dist/jstc/index.js",
       "types": "./dist/jstc/index.d.ts"
+    },
+    "./stylesheet": {
+      "import": "./dist/stylesheet/index.js",
+      "types": "./dist/stylesheet/index.d.ts"
+    },
+    "./color": {
+      "import": "./dist/color/index.js",
+      "types": "./dist/color/index.d.ts"
     }
   },
+  "dependencies": {
+    "cssom": "^0.5.0"
+  },
   "scripts": {
     "build": "tsc"
   }