@quidgest/ui 0.16.32 → 0.16.34

package/esm/components/QSelect/index.d.ts

@@ -16,6 +16,8 @@ declare const QSelect: {
         groups?: import('../QList/types').Group[];
         clearable?: boolean;
         inline?: boolean;
+        multiple?: boolean;
+        badges?: boolean;
         loading?: boolean;
         emptyValue?: any;
         itemValue?: string;
@@ -42,7 +44,7 @@ declare const QSelect: {
         itemValue: string;
         itemLabel: string;
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-        triggerEl: ({
+        trigger: ({
             $: import('vue').ComponentInternalInstance;
             $data: {};
             $props: {
@@ -111,8 +113,81 @@ declare const QSelect: {
                 extras?(_: {}): any;
             };
         }) | null;
-        contentRef: HTMLDivElement;
-        listRef: ({
+        badgesContainer: HTMLSpanElement;
+        allBadges: (({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly id?: string | undefined;
+                readonly class?: string | unknown[] | undefined;
+                readonly variant?: import('../QBadge/types').QBadgeVariant | undefined;
+                readonly color?: string | undefined;
+                readonly pill?: boolean | undefined;
+                readonly size?: import('../QBadge/types').QBadgeSize | undefined;
+                readonly removable?: boolean | undefined;
+                readonly icons?: typeof import('../QBadge/types').DEFAULT_ICONS | undefined;
+                readonly texts?: typeof import('../QBadge/types').DEFAULT_TEXTS | undefined;
+                readonly "onClick:remove"?: (() => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "click:remove") => void;
+            $el: HTMLSpanElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('../QBadge/types').QBadgeProps> & Readonly<{
+                "onClick:remove"?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                "click:remove": () => any;
+            }, string, {
+                size: import('../QBadge/types').QBadgeSize;
+                color: string;
+                variant: import('../QBadge/types').QBadgeVariant;
+                icons: typeof import('../QBadge/types').DEFAULT_ICONS;
+                texts: typeof import('../QBadge/types').DEFAULT_TEXTS;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            size: import('../QBadge/types').QBadgeSize;
+            color: string;
+            variant: import('../QBadge/types').QBadgeVariant;
+            icons: typeof import('../QBadge/types').DEFAULT_ICONS;
+            texts: typeof import('../QBadge/types').DEFAULT_TEXTS;
+        }> & Omit<Readonly<import('../QBadge/types').QBadgeProps> & Readonly<{
+            "onClick:remove"?: (() => any) | undefined;
+        }>, "size" | "color" | "variant" | "icons" | "texts"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null)[];
+        content: HTMLDivElement;
+        list: ({
             $: import('vue').ComponentInternalInstance;
             $data: {};
             $props: {
@@ -312,6 +387,8 @@ declare const QSelect: {
         groups?: import('../QList/types').Group[];
         clearable?: boolean;
         inline?: boolean;
+        multiple?: boolean;
+        badges?: boolean;
         loading?: boolean;
         emptyValue?: any;
         itemValue?: string;
@@ -351,6 +428,8 @@ declare const QSelect: {
     groups?: import('../QList/types').Group[];
     clearable?: boolean;
     inline?: boolean;
+    multiple?: boolean;
+    badges?: boolean;
     loading?: boolean;
     emptyValue?: any;
     itemValue?: string;

package/esm/components/QSelect/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAIuwzB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAJj2zB,CAAA;AAGzC,OAAO,EAAE,OAAO,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAIuwzB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAJj2zB,CAAA;AAGzC,OAAO,EAAE,OAAO,EAAE,CAAA"}

package/esm/components/QSelect/types.d.ts

@@ -25,6 +25,18 @@ export type QSelectProps = QFieldProps & {
      * @category Behavior
      */
     inline?: boolean;
+    /**
+     * Whether multiple options can be selected.
+     *
+     * @category Behavior
+     */
+    multiple?: boolean;
+    /**
+     * Whether to display the selected option(s) as badge(s).
+     *
+     * @category Presentation
+     */
+    badges?: boolean;
     /**
      * Whether the items of the list are being loaded.
      *

package/esm/components/QSelect/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/types.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAEjD,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG;IACxC;;;;OAIG;IACH,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;IAEd;;;;OAIG;IACH,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;IAEhB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;OAKG;IAEH,UAAU,CAAC,EAAE,GAAG,CAAA;IAEhB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;IAE5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;CAC5B,CAAA;AAGD,eAAO,MAAM,aAAa;;;;CAIQ,CAAA;AAGlC,eAAO,MAAM,aAAa;;;;;;;CAGM,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/types.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAEjD,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG;IACxC;;;;OAIG;IACH,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;IAEd;;;;OAIG;IACH,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;IAEhB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;OAKG;IAEH,UAAU,CAAC,EAAE,GAAG,CAAA;IAEhB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;IAE5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,aAAa,CAAA;CAC5B,CAAA;AAGD,eAAO,MAAM,aAAa;;;;CAIQ,CAAA;AAGlC,eAAO,MAAM,aAAa;;;;;;;CAGM,CAAA"}

package/esm/components/QToast/QToast.vue.js

@@ -1,4 +1,4 @@
-import { defineComponent as U, toRef as j, computed as d, onMounted as A, onUnmounted as D, createBlock as h, openBlock as y, unref as e, normalizeStyle as E, normalizeClass as H, createSlots as M, withCtx as l, createVNode as s, createCommentVNode as v, renderSlot as r, createElementVNode as p, toDisplayString as b, normalizeProps as k, guardReactiveProps as q } from "vue";
+import { defineComponent as U, toRef as j, computed as d, onMounted as A, onUnmounted as D, createBlock as b, openBlock as h, unref as e, normalizeStyle as E, normalizeClass as H, createSlots as M, withCtx as l, createVNode as i, createCommentVNode as p, renderSlot as r, createElementVNode as v, toDisplayString as y, normalizeProps as k, guardReactiveProps as q } from "vue";
 import { DEFAULT_ICONS as P } from "./types.js";
 import { QButton as w } from "../QButton/index.js";
 import { QCard as F } from "../QCard/index.js";
@@ -6,8 +6,10 @@ import { QContainer as T, QRow as $, QCol as c } from "../QGrid/index.js";
 import { QIcon as g } from "../QIcon/index.js";
 import { useTheme as L } from "../../composables/theme.js";
 import { useColor as O } from "../../composables/useColor/index.js";
-import { parseColor as x, colorToHex as G, lighten as J } from "../../utils/color.js";
-const K = { class: "q-toast__title" }, nt = /* @__PURE__ */ U({
+import { lighten as x } from "../../utils/color/manipulate.js";
+import { parseColor as G } from "../../utils/color/parse.js";
+import { rgbToHex as J } from "../../utils/color/conversion.js";
+const K = { class: "q-toast__title" }, at = /* @__PURE__ */ U({
   __name: "QToast",
   props: {
     id: {},
@@ -23,50 +25,50 @@ const K = { class: "q-toast__title" }, nt = /* @__PURE__ */ U({
   },
   emits: ["dismiss"],
   setup(Q, { emit: V }) {
-    const t = Q, S = V, B = L(), { isUtilityColor: f, style: u } = O(j(t, "color")), N = d(() => {
-      const o = f.value ? `q-toast--${t.color}` : void 0, n = t.block ? "q-toast--block" : void 0, i = t.title ? "q-toast--vertical" : void 0;
+    const t = Q, S = V, B = L(), { isUtilityColor: m, style: u } = O(j(t, "color")), N = d(() => {
+      const o = m.value ? `q-toast--${t.color}` : void 0, s = t.block ? "q-toast--block" : void 0, n = t.title ? "q-toast--vertical" : void 0;
       return [
         "q-toast",
         `q-toast--${t.variant}`,
         o,
+        s,
         n,
-        i,
         t.class
       ];
     }), C = d(() => {
-      var i;
-      const o = f.value ? R(t.color) : (i = u.value) == null ? void 0 : i.mainColor;
+      var n;
+      const o = m.value ? R(t.color) : (n = u.value) == null ? void 0 : n.mainColor;
       if (!o) return;
-      const n = x(o);
-      return G(J(n, 88));
+      const s = G(o);
+      return J(x(s, 88));
     }), z = d(() => {
-      var o, n, i;
-      return f.value ? {
+      var o, s, n;
+      return m.value ? {
         "--q-toast-tonal-color": C.value
       } : {
         "--q-toast-main-color": (o = u.value) == null ? void 0 : o.mainColor,
-        "--q-toast-on-main-color": (n = u.value) == null ? void 0 : n.onMainColor,
-        "--q-toast-hover-color": (i = u.value) == null ? void 0 : i.hoverColor,
+        "--q-toast-on-main-color": (s = u.value) == null ? void 0 : s.onMainColor,
+        "--q-toast-hover-color": (n = u.value) == null ? void 0 : n.hoverColor,
         "--q-toast-tonal-color": C.value
       };
     }), _ = d(() => t.variant === "bold" ? "bold" : "ghost");
     let a;
-    function m() {
+    function f() {
       a !== void 0 && window.clearTimeout(a), S("dismiss");
     }
     function I() {
-      a = window.setTimeout(m, t.timeout);
+      a = window.setTimeout(f, t.timeout);
     }
     function R(o) {
-      const n = B.current.value.scheme;
-      if (o in n)
-        return n[o];
+      const s = B.current.value.scheme;
+      if (o in s)
+        return s[o];
     }
     return A(() => {
       t.timeout > 0 && I();
     }), D(() => {
       a !== void 0 && window.clearTimeout(a);
-    }), (o, n) => (y(), h(e(F), {
+    }), (o, s) => (h(), b(e(F), {
       id: t.id,
       elevation: t.elevation,
       width: t.block ? "block" : void 0,
@@ -74,23 +76,23 @@ const K = { class: "q-toast__title" }, nt = /* @__PURE__ */ U({
       style: E(z.value)
     }, M({
       default: l(() => [
-        s(e(T), {
+        i(e(T), {
           fluid: "",
           class: "q-toast__body"
         }, {
           default: l(() => [
-            s(e($), {
+            i(e($), {
               align: "center",
               justify: "between"
             }, {
               default: l(() => [
-                s(e(c), null, {
+                i(e(c), null, {
                   default: l(() => [
                     r(o.$slots, "default", {}, () => [
-                      p(
+                      v(
                         "span",
                         null,
-                        b(t.text),
+                        y(t.text),
                         1
                         /* TEXT */
                       )
@@ -99,20 +101,20 @@ const K = { class: "q-toast__title" }, nt = /* @__PURE__ */ U({
                   _: 3
                   /* FORWARDED */
                 }),
-                t.title ? v("v-if", !0) : (y(), h(e(c), {
+                t.title ? p("v-if", !0) : (h(), b(e(c), {
                   key: 0,
                   cols: "auto"
                 }, {
                   default: l(() => [
                     r(o.$slots, "dismiss", {}, () => [
-                      s(e(w), {
+                      i(e(w), {
                         class: "q-toast__dismiss",
                         variant: _.value,
                         color: t.color,
-                        onClick: m
+                        onClick: f
                       }, {
                         default: l(() => [
-                          s(
+                          i(
                             e(g),
                             k(q(t.icons.close)),
                             null,
@@ -143,41 +145,41 @@ const K = { class: "q-toast__title" }, nt = /* @__PURE__ */ U({
       t.title ? {
         name: "header",
         fn: l(() => [
-          s(e(T), { fluid: "" }, {
+          i(e(T), { fluid: "" }, {
             default: l(() => [
-              s(e($), {
+              i(e($), {
                 align: "center",
                 justify: "between"
               }, {
                 default: l(() => [
-                  s(e(c), null, {
+                  i(e(c), null, {
                     default: l(() => [
-                      p("div", K, [
-                        o.$slots["title.prepend"] ? r(o.$slots, "title.prepend", { key: 0 }) : v("v-if", !0),
-                        p(
+                      v("div", K, [
+                        o.$slots["title.prepend"] ? r(o.$slots, "title.prepend", { key: 0 }) : p("v-if", !0),
+                        v(
                           "h4",
                           null,
-                          b(t.title),
+                          y(t.title),
                           1
                           /* TEXT */
                         ),
-                        o.$slots["title.append"] ? r(o.$slots, "title.append", { key: 1 }) : v("v-if", !0)
+                        o.$slots["title.append"] ? r(o.$slots, "title.append", { key: 1 }) : p("v-if", !0)
                       ])
                     ]),
                     _: 3
                     /* FORWARDED */
                   }),
-                  s(e(c), { cols: "auto" }, {
+                  i(e(c), { cols: "auto" }, {
                     default: l(() => [
                       r(o.$slots, "dismiss", {}, () => [
-                        s(e(w), {
+                        i(e(w), {
                           class: "q-toast__dismiss",
                           variant: _.value,
                           color: t.color,
-                          onClick: m
+                          onClick: f
                         }, {
                           default: l(() => [
-                            s(
+                            i(
                               e(g),
                               k(q(t.icons.close)),
                               null,
@@ -208,5 +210,5 @@ const K = { class: "q-toast__title" }, nt = /* @__PURE__ */ U({
   }
 });
 export {
-  nt as default
+  at as default
 };

package/esm/composables/useColor/index.js

@@ -1,41 +1,44 @@
-import { computed as s, unref as v } from "vue";
-import { parseColor as g, rgbToHsl as d, darken as b, colorToHex as p, getContrastingColor as y, rgbToVariableString as c } from "../../utils/color.js";
-import { useTheme as T } from "../theme.js";
-function k(o) {
-  const t = s(() => v(o)), i = s(
-    () => t.value ? !H(t.value) : !1
-  ), C = s(() => {
-    const e = t.value;
-    if (!e) return;
-    let n = e;
-    const f = T();
+import { computed as l, unref as g } from "vue";
+import { useTheme as v } from "../theme.js";
+import { rgbToHsl as p, rgbToHex as b, rgbToVariableString as c } from "../../utils/color/conversion.js";
+import { darken as d } from "../../utils/color/manipulate.js";
+import { getContrastingColor as y } from "../../utils/color/contrast.js";
+import { parseColor as T } from "../../utils/color/parse.js";
+function K(o) {
+  const e = l(() => g(o)), i = l(
+    () => e.value ? !H(e.value) : !1
+  ), m = l(() => {
+    const t = e.value;
+    if (!t) return;
+    let n = t;
+    const C = v();
     if (i.value) {
-      const l = e;
-      n = f.current.value.scheme[l] ?? e;
+      const s = t;
+      n = C.current.value.scheme[s] ?? t;
     }
     let r;
     try {
-      if (r = g(n), !r) return;
-    } catch (l) {
-      console.error("Failed to parse color:", l);
+      if (r = T(n), !r) return;
+    } catch (s) {
+      console.error("Failed to parse color:", s);
       return;
     }
-    const h = d(r), a = y(h.l), u = b(r, 25), m = p(u);
+    const f = p(r), a = y(f.l), u = d(r, 25), h = b(u);
     return {
       mainColor: n,
       mainColorRgb: c(r),
       onMainColor: a,
-      hoverColor: m,
+      hoverColor: h,
       hoverColorRgb: c(u),
       onHoverColor: a
     };
   });
-  return { isUtilityColor: i, style: C };
+  return { isUtilityColor: i, style: m };
 }
 function H(o) {
   return o.startsWith("#") || o.startsWith("rgb") || o.startsWith("hsl");
 }
 export {
   H as isCssColor,
-  k as useColor
+  K as useColor
 };

package/esm/templates/theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/templates/theme.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,eAAO,MAAM,uBAAuB,EAAE,WAoCrC,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,WAoCpC,CAAA"}
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/templates/theme.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,eAAO,MAAM,uBAAuB,EAAE,WAsDrC,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,WAsDpC,CAAA"}

package/esm/templates/theme.js

@@ -1,4 +1,4 @@
-const a = {
+const n = {
   primary: "#008ad2",
   primaryLight: "#cde5ff",
   primaryDark: "#006398",
@@ -25,16 +25,33 @@ const a = {
   neutral: "#7c858d",
   neutralLight: "#c4c5ca",
   neutralDark: "#40474f",
-  onBackground: "#202428",
   onPrimary: "#fff",
+  onPrimaryLight: "#202428",
+  onPrimaryDark: "#fff",
   onSecondary: "#fff",
+  onSecondaryLight: "#202428",
+  onSecondaryDark: "#fff",
   onHighlight: "#fff",
+  onHighlightLight: "#202428",
+  onHighlightDark: "#fff",
+  onInfo: "#fff",
+  onInfoLight: "#202428",
+  onInfoDark: "#fff",
   onSuccess: "#fff",
+  onSuccessLight: "#202428",
+  onSuccessDark: "#fff",
   onWarning: "#fff",
+  onWarningLight: "#202428",
+  onWarningDark: "#fff",
   onDanger: "#fff",
-  onInfo: "#fff",
-  onNeutral: "#fff"
-}, f = {
+  onDangerLight: "#202428",
+  onDangerDark: "#fff",
+  onBackground: "#202428",
+  onContainer: "#202428",
+  onNeutral: "#fff",
+  onNeutralLight: "#202428",
+  onNeutralDark: "#fff"
+}, a = {
   primary: "#4da6e0",
   primaryLight: "#1a2832",
   primaryDark: "#87c5f0",
@@ -61,17 +78,34 @@ const a = {
   neutral: "#9ca3ab",
   neutralLight: "#2a2d31",
   neutralDark: "#c8ced6",
-  onBackground: "#e0e0e0",
   onPrimary: "#000",
+  onPrimaryLight: "#e0e0e0",
+  onPrimaryDark: "#000",
   onSecondary: "#000",
+  onSecondaryLight: "#e0e0e0",
+  onSecondaryDark: "#000",
   onHighlight: "#000",
+  onHighlightLight: "#e0e0e0",
+  onHighlightDark: "#000",
+  onInfo: "#000",
+  onInfoLight: "#e0e0e0",
+  onInfoDark: "#000",
   onSuccess: "#000",
+  onSuccessLight: "#e0e0e0",
+  onSuccessDark: "#000",
   onWarning: "#000",
+  onWarningLight: "#e0e0e0",
+  onWarningDark: "#000",
   onDanger: "#000",
-  onInfo: "#000",
-  onNeutral: "#000"
+  onDangerLight: "#e0e0e0",
+  onDangerDark: "#000",
+  onBackground: "#e0e0e0",
+  onContainer: "#e0e0e0",
+  onNeutral: "#000",
+  onNeutralLight: "#e0e0e0",
+  onNeutralDark: "#000"
 };
 export {
-  f as defaultDarkColorScheme,
-  a as defaultLightColorScheme
+  a as defaultDarkColorScheme,
+  n as defaultLightColorScheme
 };

package/esm/utils/color/contrast.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Determines a contrasting color (black or white) based on the given luminance.
+ * Useful for ensuring text readability against a background color with the given luminance.
+ *
+ * @param luminance - The luminance value (between 0 and 100) of the background color.
+ * @returns A hex string representing either black ('#000') or white ('#fff').
+ */
+export declare function getContrastingColor(luminance: number): '#000' | '#fff';
+/**
+ * Calculates the complementary color for a given color string.
+ * The complementary color is the color directly opposite on the color wheel,
+ * often used for strong visual contrast.
+ *
+ * @param color - The color string to convert. Can be in various formats (e.g., hex, rgb, rgba, hsl, hsla).
+ * @returns A hex string representing the complementary color.
+ */
+export declare function getComplementaryColor(color: string): string;
+//# sourceMappingURL=contrast.d.ts.map

package/esm/utils/color/contrast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contrast.d.ts","sourceRoot":"","sources":["../../../src/utils/color/contrast.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAMtE;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAW3D"}

package/esm/utils/color/contrast.js

@@ -0,0 +1,6 @@
+function r(t) {
+  return t > 50 ? "#000" : "#fff";
+}
+export {
+  r as getContrastingColor
+};

package/esm/utils/color/conversion.d.ts

@@ -0,0 +1,41 @@
+import { RGB, HSL } from './types';
+/**
+ * Converts a color from RGB to HSL space.
+ *
+ * @param color The color to convert.
+ * @returns An object representing the color in HSL space.
+ */
+export declare function rgbToHsl(rgb: RGB): HSL;
+/**
+ * Converts a color from HSL to RGB space.
+ *
+ * @param h The hue component of the color, in the range [0, 1].
+ * @param s The saturation component of the color, in the range [0, 1].
+ * @param l The lightness component of the color, in the range [0, 1].
+ * @returns A `RGB` object representing the color in RGB space.
+ */
+export declare function hslToRgb(hsl: HSL): RGB;
+/**
+ * Converts a hue value to a corresponding RGB value.
+ *
+ * @param p The first RGB component.
+ * @param q The second RGB component.
+ * @param t The hue value.
+ * @returns The corresponding RGB value.
+ */
+export declare function hueToRgb(p: number, q: number, t: number): number;
+/**
+ * Converts a RGB value to a hex string.
+ *
+ * @param rgb The color to convert.
+ * @returns A hex string representing the color.
+ */
+export declare function rgbToHex(rgb: RGB): string;
+/**
+ * Converts an RGB object to a string in the format 'r g b'.
+ *
+ * @param rgb The RGB object to convert.
+ * @returns A string representing the color in 'r g b' format.
+ */
+export declare function rgbToVariableString(rgb: RGB): string;
+//# sourceMappingURL=conversion.d.ts.map

package/esm/utils/color/conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion.d.ts","sourceRoot":"","sources":["../../../src/utils/color/conversion.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAqCtC;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAuBtC;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOhE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAMzC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAEpD"}

package/esm/utils/color/conversion.js

@@ -0,0 +1,59 @@
+function f(t) {
+  const r = t.r / 255, n = t.g / 255, o = t.b / 255, s = Math.max(r, n, o), c = Math.min(r, n, o);
+  let a = 0, e;
+  const i = (s + c) / 2;
+  if (s === c)
+    a = e = 0;
+  else {
+    const u = s - c;
+    switch (e = i > 0.5 ? u / (2 - s - c) : u / (s + c), s) {
+      case r:
+        a = (n - o) / u + (n < o ? 6 : 0);
+        break;
+      case n:
+        a = (o - r) / u + 2;
+        break;
+      case o:
+        a = (r - n) / u + 4;
+        break;
+    }
+    a /= 6;
+  }
+  return {
+    h: Math.round(a * 360),
+    s: Math.round(e * 100),
+    l: Math.round(i * 100)
+  };
+}
+function b(t) {
+  const r = t.h / 360, n = t.s / 100, o = t.l / 100;
+  let s, c, a;
+  if (n === 0)
+    s = c = a = o;
+  else {
+    const e = o < 0.5 ? o * (1 + n) : o + n - o * n, i = 2 * o - e;
+    s = h(i, e, r + 1 / 3), c = h(i, e, r), a = h(i, e, r - 1 / 3);
+  }
+  return {
+    r: Math.round(s * 255),
+    g: Math.round(c * 255),
+    b: Math.round(a * 255)
+  };
+}
+function h(t, r, n) {
+  return n < 0 && (n += 1), n > 1 && (n -= 1), n < 1 / 6 ? t + (r - t) * 6 * n : n < 1 / 2 ? r : n < 2 / 3 ? t + (r - t) * (2 / 3 - n) * 6 : t;
+}
+function d(t) {
+  const r = t.r.toString(16).padStart(2, "0"), n = t.g.toString(16).padStart(2, "0"), o = t.b.toString(16).padStart(2, "0");
+  return `#${r}${n}${o}`;
+}
+function g(t) {
+  return `${t.r} ${t.g} ${t.b}`;
+}
+export {
+  b as hslToRgb,
+  h as hueToRgb,
+  d as rgbToHex,
+  f as rgbToHsl,
+  g as rgbToVariableString
+};

package/esm/utils/color/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './parse';
+export * from './conversion';
+export * from './manipulate';
+export * from './contrast';
+export * from './merge';
+//# sourceMappingURL=index.d.ts.map

package/esm/utils/color/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/color/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA"}