unocss-preset-magicolor 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TodayDrizzle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# unocss-preset-magicolor
+
+Check out the [documentation](https://github.com/nixwai/unocss-preset-magicolor/blob/main/README.md) for more details.
+
+## License
+
+[MIT](../../LICENSE) License

package/dist/helper.js

@@ -0,0 +1,5 @@
+function o() {
+}
+export {
+  o as updateMagicColor
+};

package/dist/index.js

@@ -0,0 +1,386 @@
+import { notLastChildSelectorVariant as A } from "@unocss/preset-wind4/rules";
+import { colorCSSGenerator as H, parseColor as y, defineProperty as f, generateThemeVariable as B, themeTracking as I, detectThemeValue as G, h as x, SpecialColorKey as F, numberResolver as R, hyphenate as D } from "@unocss/preset-wind4/utils";
+import { converter as q, formatHex as K } from "culori";
+import { mc as N } from "magic-color";
+import { notNull as J } from "unocss";
+const Q = q("oklch");
+function h(r) {
+  return r && Number.parseFloat(r.toString()) || 0;
+}
+function C(r) {
+  if (!r)
+    return;
+  if (r.type === "oklch")
+    return r.components[0].toString().includes("%") && (r.components[0] = h(r.components[0]) / 100), r.components = r.components.map(h), r;
+  const o = r.components.join(" "), e = Q(r.type === "hex" ? o : `${r.type}(${o})`);
+  if (e)
+    return {
+      type: "oklch",
+      components: [e.l, e.c, e.h ?? 0],
+      alpha: r.alpha
+    };
+}
+const M = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+function O(r) {
+  let o = Number(r);
+  o = o <= 50 ? 50 : o, o = o >= 950 ? 950 : o;
+  let e = Math.floor(o / 100) * 100;
+  e = e <= 50 ? 50 : e;
+  let n = Math.floor((o + 100) / 100) * 100;
+  return n = n >= 950 ? 950 : n, { originDepth: o, beforeDepth: e, afterDepth: n };
+}
+function U(r, o) {
+  let e = y(r, o);
+  if (e?.color)
+    return e;
+  const [n, a, c] = r.split(/[:/]/), s = n.match(/.*-(\d+)/)?.[1], t = n?.split(/-\d+-?/)[0];
+  if (e = {
+    opacity: a,
+    modifier: c,
+    name: t,
+    no: s,
+    color: "",
+    alpha: a && `${a}%`,
+    keys: void 0,
+    cssColor: void 0
+  }, !t || !Number.isNaN(Number(t)))
+    return console.error(`[unocss-preset-margicolor][mc-${r}] The color '${t}' is invalid.`), e;
+  if (!s)
+    return e;
+  const { originDepth: i, beforeDepth: u, afterDepth: $ } = O(s);
+  let l = y(`${t}-${u}`, o)?.cssColor, m = y(`${t}-${$}`, o)?.cssColor;
+  if (!l || !m)
+    try {
+      const g = y(t, o)?.color, k = g ? K(g) : void 0;
+      if (k && N.valid(k)) {
+        const v = N.theme(k);
+        l || (l = C({ type: "hex", components: [v[u]], alpha: 1 })), m || (m = C({ type: "hex", components: [v[$]], alpha: 1 }));
+      }
+    } catch (g) {
+      console.error(`[unocss-preset-margicolor] Error parsing ${r}: get ${t} theme fail, please use another color.`), console.error(g);
+    }
+  if (l = C(l), m = C(m), !l || !m)
+    return e;
+  const b = (i - u) / (i < 100 || i > 950 ? 50 : 100), d = Array.from({ length: 3 }).map((g, k) => {
+    const v = l.components, w = m.components, S = h(v[k]) + (h(w[k]) - h(v[k])) * b;
+    return `${Math.round(S * 1e3) / 1e3}`;
+  });
+  return e.color = `oklch(${d.join(" ")})`, e;
+}
+function W(r) {
+  const o = {};
+  if (!r || r.color)
+    return { colorData: r, cssVariable: o };
+  const { name: e, no: n } = r;
+  if (!n)
+    return r.color = `var(--mc-${e}-color)`, { colorData: r, cssVariable: o };
+  const { originDepth: a, beforeDepth: c, afterDepth: s } = O(n), t = `--mc-${e}-${a}-l`, i = `--mc-${e}-${a}-c`, u = `--mc-${e}-${a}-h`;
+  if (!M.includes(a)) {
+    const $ = (a - c) / (a < 100 || a > 950 ? 50 : 100), [l, m, b] = ["l", "c", "h"].map((d) => `calc(var(--mc-${e}-${c}-${d}) + ${$} * (var(--mc-${e}-${s}-${d}) - var(--mc-${e}-${c}-${d})))`);
+    Object.assign(o, { [t]: l, [i]: m, [u]: b });
+  }
+  return r.color = `oklch(var(${t}) var(${i}) var(${u}))`, { colorData: r, cssVariable: o };
+}
+function j(r, o) {
+  const e = U(r, o);
+  return W(e);
+}
+function p(r, o) {
+  return ([, e], n) => {
+    const { colorData: a, cssVariable: c } = j(e ?? "", n.theme);
+    if (a?.color) {
+      const s = H(a, r, o, n);
+      return s && s.push({
+        [n.symbols.selector]: (t) => t,
+        ...c
+      }), s;
+    }
+  };
+}
+const X = {
+  transparent: "transparent",
+  current: "currentColor",
+  inherit: "inherit"
+}, Y = {
+  "gradient-position": f("--un-gradient-position"),
+  "gradient-from": f("--un-gradient-from", { syntax: "<color>", initialValue: "#0000" }),
+  "gradient-via": f("--un-gradient-via", { syntax: "<color>", initialValue: "#0000" }),
+  "gradient-to": f("--un-gradient-to", { syntax: "<color>", initialValue: "#0000" }),
+  "gradient-stops": f("--un-gradient-stops"),
+  "gradient-via-stops": f("--un-gradient-via-stops"),
+  "gradient-from-position": f("--un-gradient-from-position", { syntax: "<length-percentage>", initialValue: "0%" }),
+  "gradient-via-position": f("--un-gradient-via-position", { syntax: "<length-percentage>", initialValue: "50%" }),
+  "gradient-to-position": f("--un-gradient-to-position", { syntax: "<length-percentage>", initialValue: "100%" })
+};
+function Z() {
+  return function* ([, r, o], { theme: e, symbols: n }) {
+    const a = {}, { colorData: c, cssVariable: s } = j(o, e);
+    if (c) {
+      const { color: t, keys: i, alpha: u } = c;
+      if (t) {
+        if (Object.values(X).includes(t))
+          a[`--un-gradient-${r}`] = t;
+        else {
+          a[`--un-${r}-opacity`] = u;
+          const $ = i ? B("colors", i) : t;
+          a[`--un-gradient-${r}`] = `color-mix(in oklab, ${$} var(--un-${r}-opacity), transparent)`, yield f(`--un-${r}-opacity`, { syntax: "<percentage>", initialValue: "100%" });
+        }
+        i && I("colors", i), e && G(t, e);
+      }
+    } else
+      a[`--un-gradient-${r}`] = x.bracket.cssvar(o);
+    if (a[`--un-gradient-${r}`]) {
+      switch (r) {
+        case "from":
+          yield {
+            ...a,
+            "--un-gradient-stops": "var(--un-gradient-via-stops, var(--un-gradient-position), var(--un-gradient-from) var(--un-gradient-from-position), var(--un-gradient-to) var(--un-gradient-to-position))"
+          };
+          break;
+        case "via":
+          yield {
+            ...a,
+            "--un-gradient-via-stops": "var(--un-gradient-position), var(--un-gradient-from) var(--un-gradient-from-position), var(--un-gradient-via) var(--un-gradient-via-position), var(--un-gradient-to) var(--un-gradient-to-position)",
+            "--un-gradient-stops": "var(--un-gradient-via-stops)"
+          };
+          break;
+        case "to":
+          yield {
+            ...a,
+            "--un-gradient-stops": "var(--un-gradient-via-stops, var(--un-gradient-position), var(--un-gradient-from) var(--un-gradient-from-position), var(--un-gradient-to) var(--un-gradient-to-position))"
+          };
+          break;
+        case "stops":
+          yield { ...a };
+          break;
+      }
+      for (const t of Object.values(Y))
+        yield t;
+      yield {
+        [n.selector]: (t) => t,
+        ...s
+      };
+    }
+  };
+}
+const T = {
+  l: ["-left"],
+  r: ["-right"],
+  t: ["-top"],
+  b: ["-bottom"],
+  s: ["-inline-start"],
+  e: ["-inline-end"],
+  // 'x': ['-left', '-right'],
+  // 'y': ['-top', '-bottom'],
+  x: ["-inline"],
+  y: ["-block"],
+  "": [""],
+  bs: ["-block-start"],
+  be: ["-block-end"],
+  is: ["-inline-start"],
+  ie: ["-inline-end"],
+  block: ["-block-start", "-block-end"],
+  inline: ["-inline-start", "-inline-end"]
+};
+function V([, r = "", o], e) {
+  if (r in T) {
+    const { colorData: n, cssVariable: a } = j(o ?? "", e.theme);
+    if (n) {
+      const c = T[r].map((s) => oo(s)(n, e)).filter(J);
+      return [
+        c.map((s) => s[0]).reduce((s, t) => (Object.assign(s, t), s), {}),
+        ...c.flatMap((s) => s.slice(1)),
+        {
+          [e.symbols.selector]: (s) => s,
+          ...a
+        }
+      ];
+    }
+  }
+}
+function oo(r) {
+  return (o, e) => {
+    const n = H(o, `border${r}-color`, `border${r}`, e);
+    if (n) {
+      const a = n[0];
+      return o?.color && !Object.values(F).includes(o.color) && !o.alpha && r && r !== "" && (a[`--un-border${r}-opacity`] = "var(--un-border-opacity)"), n;
+    }
+  };
+}
+const ro = {
+  "mask-image": "var(--un-mask-linear), var(--un-mask-radial), var(--un-mask-conic)",
+  "mask-composite": "intersect"
+}, z = {
+  t: ["top"],
+  b: ["bottom"],
+  l: ["left"],
+  r: ["right"],
+  x: ["left", "right"],
+  y: ["top", "bottom"]
+}, L = "linear-gradient(#fff, #fff)";
+function P([r, o = "", e, n], a) {
+  const c = { ...ro }, s = [];
+  if (s.push(...["linear", "radial", "conic"].map((t) => f(`--un-mask-${t}`, { initialValue: L }))), o in z) {
+    c["--un-mask-linear"] = "var(--un-mask-left), var(--un-mask-right), var(--un-mask-bottom), var(--un-mask-top)";
+    for (const t of z[o]) {
+      c[`--un-mask-${t}`] = `linear-gradient(to ${t}, var(--un-mask-${t}-from-color) var(--un-mask-${t}-from-position), var(--un-mask-${t}-to-color) var(--un-mask-${t}-to-position))`, R(n) != null ? (I("spacing"), c[`--un-mask-${t}-${e}-position`] = `calc(var(--spacing) * ${x.bracket.cssvar.fraction.number(n)})`) : c[`--un-mask-${t}-${e}-position`] = x.bracket.cssvar.fraction.rem(n);
+      const i = p(`--un-mask-${t}-${e}-color`, D("colors"))([r, n], a);
+      if (i) {
+        const [u, ...$] = i;
+        Object.assign(c, u), s.push(...$);
+      }
+      s.push(...["from", "to"].flatMap((u) => [
+        f(`--un-mask-${t}-${u}-position`, { syntax: "<length-percentage>", initialValue: u === "from" ? "0%" : "100%" }),
+        f(`--un-mask-${t}-${u}-color`, { syntax: "<color>", initialValue: u === "from" ? "black" : "transparent" })
+      ]));
+    }
+    s.push(...["top", "right", "bottom", "left"].map((t) => f(`--un-mask-${t}`, { initialValue: L })));
+  } else {
+    if (e == null)
+      o === "radial" ? (c["--un-mask-radial"] = "radial-gradient(var(--un-mask-radial-stops, var(--un-mask-radial-size)))", c["--un-mask-radial-size"] = x.bracket.cssvar.rem(n)) : (c[`--un-mask-${o}`] = `${o}-gradient(var(--un-mask-${o}-stops, var(--un-mask-${o}-position)))`, c[`--un-mask-${o}-position`] = R(n) ? `calc(1deg * ${x.bracket.cssvar.number(n)})` : x.bracket.cssvar.fraction(n));
+    else {
+      const t = {
+        linear: "",
+        radial: "var(--un-mask-radial-shape) var(--un-mask-radial-size) at ",
+        conic: "from "
+      };
+      c[`--un-mask-${o}-stops`] = `${t[o]}var(--un-mask-${o}-position), var(--un-mask-${o}-from-color) var(--un-mask-${o}-from-position), var(--un-mask-${o}-to-color) var(--un-mask-${o}-to-position)`, c[`--un-mask-${o}`] = `${o}-gradient(var(--un-mask-${o}-stops))`;
+      const i = p(`--un-mask-${o}-${e}-color`, D("colors"))([r, n], a);
+      if (i) {
+        const [u, ...$] = i;
+        Object.assign(c, u), s.push(...$);
+      }
+    }
+    o === "radial" && s.push(f("--un-mask-radial-shape", { initialValue: "ellipse" }), f("--un-mask-radial-size", { initialValue: "farthest-corner" })), s.push(...["from", "to"].flatMap((t) => [
+      f(`--un-mask-${o}-position`, { initialValue: o === "radial" ? "center" : "0deg" }),
+      f(`--un-mask-${o}-${t}-position`, { syntax: "<length-percentage>", initialValue: t === "from" ? "0%" : "100%" }),
+      f(`--un-mask-${o}-${t}-color`, { syntax: "<color>", initialValue: t === "from" ? "black" : "transparent" })
+    ]));
+  }
+  return [c, ...s];
+}
+function E(r) {
+  return (o, e) => {
+    const n = D(r);
+    return p(`--un-${n}-color`, n)(o, e);
+  };
+}
+const eo = [
+  // common style colors
+  [/^(?:color|c)-mc-(.+)$/, p("color", "text"), { autocomplete: "(color|c)-mc-$colors" }],
+  [/^text-(?:color-)?mc-(.+)$/, p("color", "text"), { autocomplete: "(text|text-color)-mc-$colors" }],
+  [/^outline-(?:color-)?mc-(.+)$/, p("outline-color", "outline"), { autocomplete: "(outline|outline-color)-mc-$colors" }],
+  [/^accent-mc-(.+)$/, p("accent-color", "accent"), { autocomplete: "accent-mc-$colors" }],
+  [/^caret-mc-(.+)$/, p("caret-color", "caret"), { autocomplete: "caret-mc-$colors" }],
+  [/^bg-mc-(.+)$/, p("background-color", "bg"), { autocomplete: "bg-mc-$colors" }],
+  // from https://github.com/unocss/unocss/blob/main/packages-presets/preset-wind4/src/rules/decoration.ts
+  [/^(?:underline|decoration)-mc-(.+)$/, (r, o) => {
+    const e = p("text-decoration-color", "line")(r, o);
+    if (e) {
+      const n = e[0];
+      return n["-webkit-text-decoration-color"] = n["text-decoration-color"], e;
+    }
+  }, { autocomplete: "(underline|decoration)-mc-$colors" }],
+  // from https://github.com/unocss/unocss/blob/main/packages-presets/preset-wind4/src/rules/divide.ts
+  [/^divide-mc-(.+)$/, function* (r, o) {
+    const e = p("border-color", "divide")(r, o);
+    e && (yield {
+      [o.symbols.variants]: [A(r[0])],
+      ...e[0]
+    }, yield e[1]);
+  }, { autocomplete: "divide-mc-$colors" }],
+  [/^(?:filter-)?drop-shadow-color-mc-(.+)$/, p("--un-drop-shadow-color", "drop-shadow"), { autocomplete: "divide-mc-$colors" }],
+  [/^\$ placeholder-mc-(.+)$/, p("color", "placeholder"), { autocomplete: "placeholder-mc-$colors" }],
+  [/^ring-mc-(.+)$/, p("--un-ring-color", "ring"), { autocomplete: "ring-mc-$colors" }],
+  [/^inset-ring-mc-(.+)$/, p("--un-inset-ring-color", "inset-ring"), { autocomplete: "inset-ring-mc-$colors" }],
+  [/^ring-offset-mc-(.+)$/, p("--un-ring-offset-color", "ring-offset"), { autocomplete: "ring-offset-mc-$colors" }],
+  [/^shadow-mc-(.+)$/, E("shadow"), { autocomplete: ["shadow-$colors", "shadow-mc-$shadow"] }],
+  [/^inset-shadow-mc(.+)$/, E("insetShadow"), { autocomplete: ["inset-shadow-mc-$colors", "inset-shadow-mc-$insetShadow"] }],
+  [/^fill-mc-(.+)$/, p("fill", "fill"), { autocomplete: "fill-mc-$colors" }],
+  [/^stroke-mc-(.+)$/, p("stroke", "stroke"), { autocomplete: "stroke-mc-$colors" }],
+  [/^text-stroke-mc-(.+)$/, p("-webkit-text-stroke-color", "text-stroke"), { autocomplete: "text-stroke-mc-$colors" }],
+  [/^text-shadow-(?:color-)?mc-(.+)$/, p("--un-text-shadow-color", "text-shadow"), { autocomplete: ["text-shadow(-color)?-mc-$colors"] }],
+  [/^mask-(linear|radial|conic)-(from|to)-mc-(.+)$/, P, { autocomplete: ["mask-(linear|radial|conic)-(from|to)-mc-$colors"] }],
+  [/^mask-([trblxy])-(from|to)-mc-(.+)$/, P, { autocomplete: ["mask-(x|y|t|b|l|r)-(from|to)-mc-$colors"] }],
+  // border style colors
+  [/^(?:border|b)-()(?:color-)?mc-(.+)$/, V, { autocomplete: ["(border|b)-mc-$colors", "(border|b)-<directions>-mc-$colors"] }],
+  [/^(?:border|b)-([xy])-(?:color-)?mc-(.+)$/, V],
+  [/^(?:border|b)-([rltbse])-(?:color-)?mc-(.+)$/, V],
+  [/^(?:border|b)-(block|inline)-(?:color-)?mc-(.+)$/, V],
+  [/^(?:border|b)-([bi][se])-(?:color-)?mc-(.+)$/, V],
+  // bg gradient color
+  [/^(from|via|to|stops)-mc-(.+)$/, Z()]
+], to = [
+  [/^mc-(.+)$/, no]
+];
+function no([, r], { theme: o }) {
+  const e = {}, [n, a] = r.split("_");
+  if (!a)
+    return;
+  if (y(n, o)?.color) {
+    console.error(`[unocss-preset-margicolor][mc-${r}] The color name '${n}' has been configured in the theme, please use the another name.`);
+    return;
+  }
+  const [c] = a.split(/[:/]/), s = c.match(/.*-(\d+)/)?.[1], t = c?.split(/-\d+-?/)[0];
+  if (!t || !Number.isNaN(Number(t))) {
+    console.error(`[unocss-preset-margicolor][mc-${r}] The color '${t}' is invalid.`);
+    return;
+  }
+  const i = {};
+  let u = !1;
+  for (const l of M) {
+    const m = y(`${t}-${l}`, o)?.cssColor;
+    m ? i[l] = m : u = !0;
+  }
+  if (u)
+    try {
+      const l = y(t, o)?.color, m = l ? K(l) : void 0;
+      if (m && N.valid(m)) {
+        const b = N.theme(m);
+        for (const d of M)
+          if (!i[d]) {
+            const g = C({ type: "hex", components: [b[d]], alpha: 1 });
+            i[d] = g;
+          }
+      }
+    } catch (l) {
+      console.error(`[unocss-preset-margicolor] Error parsing ${r}: get ${t} theme fail, please use another color.`), console.error(l);
+    }
+  for (const l of M)
+    i[l] = C(i[l]);
+  const $ = y(c, o);
+  if ($?.color)
+    e[`--mc-${n}-color`] = $.color;
+  else if (s) {
+    const { originDepth: l, beforeDepth: m, afterDepth: b } = O(s);
+    if (i[m] && i[b]) {
+      const d = (l - m) / 100, g = Array.from({ length: 3 }).map((k, v) => {
+        const w = i[m].components, S = i[b].components, _ = h(w[v]) + (h(S[v]) - h(w[v])) * d;
+        return `${Math.round(_ * 1e3) / 1e3}`;
+      });
+      e[`--mc-${n}-color`] = `oklch(${g.join(" ")})`;
+    }
+  }
+  for (const l of M)
+    if (i[l]) {
+      const m = i[l].components;
+      e[`--mc-${n}-${l}-l`] = Math.round(h(m[0]) * 1e3) / 1e3, e[`--mc-${n}-${l}-c`] = Math.round(h(m[1]) * 1e3) / 1e3, e[`--mc-${n}-${l}-h`] = Math.round(h(m[2]) * 1e3) / 1e3;
+    }
+  return e;
+}
+const ao = [
+  eo,
+  to
+].flat();
+function uo(r) {
+  return {
+    name: "unocss-preset-magicolor",
+    layer: "unocss-preset-magicolor",
+    layers: { "unocss-preset-magicolor": -100 },
+    rules: ao
+  };
+}
+export {
+  uo as default,
+  uo as presetMagicolor
+};

package/dist/types/helper.d.ts

@@ -0,0 +1 @@
+export declare function updateMagicColor(): void;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+import { Preset } from 'unocss';
+import { PresetMcOptions } from './types';
+export declare function presetMagicolor(_options?: PresetMcOptions): Preset;
+export * from './types';
+export default presetMagicolor;

package/dist/types/rules/color-style.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from 'unocss';
+export declare const colorStyle: Rule[];

package/dist/types/rules/color-variable.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from 'unocss';
+export declare const colorVariable: Rule[];

package/dist/types/rules/index.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from 'unocss';
+export declare const rules: Rule[];

package/dist/types/types.d.ts

@@ -0,0 +1,3 @@
+/** PresetMcOptions */
+export interface PresetMcOptions {
+}

package/dist/types/typing.d.ts

@@ -0,0 +1,2 @@
+import { ThemeMetas } from 'magic-color';
+export type ThemeKey = keyof ThemeMetas;

package/dist/types/utils/bg-gradient.d.ts

@@ -0,0 +1,3 @@
+import { Theme } from '@unocss/preset-wind4';
+import { RuleContext } from 'unocss';
+export declare function mcBgGradientColorResolver(): ([, position, body]: string[], { theme, symbols }: RuleContext<Theme>) => Generator<import('unocss').CSSValueInput, void, unknown>;

package/dist/types/utils/border.d.ts

@@ -0,0 +1,3 @@
+import { Theme } from '@unocss/preset-wind4';
+import { CSSEntries, CSSValueInput, RuleContext } from 'unocss';
+export declare function mcBorderColorResolver([, a, b]: string[], ctx: RuleContext<Theme>): CSSEntries | (CSSValueInput | string)[] | undefined;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './bg-gradient';
+export * from './border';
+export * from './mask';
+export * from './shadow';
+export * from './transforms';
+export * from './utilities';

package/dist/types/utils/mask.d.ts

@@ -0,0 +1,3 @@
+import { Theme } from '@unocss/preset-wind4';
+import { CSSObject, RuleContext } from 'unocss';
+export declare function handleImage([_, gradient, direction, val]: string[], ctx: RuleContext<Theme>): (string | CSSObject | Partial<import('unocss').ControlSymbolsValue> | import('unocss').CSSEntriesInput)[];

package/dist/types/utils/shadow.d.ts

@@ -0,0 +1,3 @@
+import { Theme } from '@unocss/preset-wind4';
+import { CSSObject, CSSValueInput, RuleContext } from 'unocss';
+export declare function handleShadow(themeKey: 'shadow' | 'insetShadow'): (match: RegExpMatchArray, ctx: RuleContext<Theme>) => CSSObject | (CSSValueInput | string)[] | undefined;

package/dist/types/utils/transforms.d.ts

@@ -0,0 +1,5 @@
+import { CSSColorValue } from '@unocss/preset-wind4/utils';
+/** to number */
+export declare function toNum(value?: string | number): number;
+/** to oklch color */
+export declare function toOklch(cssColor?: CSSColorValue): CSSColorValue | undefined;

package/dist/types/utils/utilities.d.ts

@@ -0,0 +1,23 @@
+import { Theme } from '@unocss/preset-wind4';
+import { CSSObject, CSSValueInput, RuleContext } from 'unocss';
+import { ThemeKey } from '../typing';
+export declare const themeMetaList: ThemeKey[];
+export declare function resolveDepth(no: string): {
+    originDepth: number;
+    beforeDepth: number;
+    afterDepth: number;
+};
+export declare function parseMagicColor(body: string, theme: Theme): {
+    colorData: {
+        opacity: string | undefined;
+        modifier: string | undefined;
+        name: string;
+        no: string | undefined;
+        color: string;
+        alpha: string | undefined;
+        keys: string[] | undefined;
+        readonly cssColor: import('@unocss/preset-wind4/utils').CSSColorValue | undefined;
+    } | undefined;
+    cssVariable: CSSObject;
+};
+export declare function mcColorResolver(property: string, varName: string): ([, body]: string[], ctx: RuleContext<Theme>) => (CSSValueInput | string)[] | undefined;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "unocss-preset-magicolor",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Unocss预设",
+  "author": "nxy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nixwai/unocss-preset-magicolor"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./helper": {
+      "types": "./dist/types/helper.d.ts",
+      "import": "./dist/helper.js"
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@unocss/preset-wind4": "66.5.4",
+    "culori": "^4.0.2",
+    "magic-color": "^2.1.0"
+  },
+  "devDependencies": {
+    "@types/culori": "^4.0.1",
+    "unocss": "^66.5.4"
+  }
+}