@bccampus/ui-components 0.3.0 → 0.4.0

package/dist/generate-tiles-DuagGD1d.js

@@ -0,0 +1,244 @@
+import { jsx as n } from "react/jsx-runtime";
+import { c as m } from "./utils-CRiPKpXj.js";
+const r = {
+  Blank: 0,
+  Rand: 1,
+  Mosaic: 2,
+  MosaicCircle: 3,
+  MosaicDiamond: 4,
+  Square: 6,
+  Circle: 7,
+  Diamond: 8,
+  Hexagon: 9,
+  RandBasic: 10,
+  TriangleSE: 11,
+  TriangleSW: 12,
+  TriangleNW: 13,
+  TriangleNE: 14,
+  TriangleRand: 15,
+  CaretN: 16,
+  CaretE: 17,
+  CaretS: 18,
+  CaretW: 19,
+  CaretRand: 20,
+  PieSE: 21,
+  PieSW: 22,
+  PieNW: 23,
+  PieNE: 24,
+  PieRand: 25
+}, p = [
+  r.Square,
+  r.Circle,
+  r.Diamond,
+  r.Hexagon,
+  r.TriangleSE,
+  r.TriangleSW,
+  r.TriangleNW,
+  r.TriangleNE,
+  r.PieSE,
+  r.PieSW,
+  r.PieNW,
+  r.PieNE
+], h = {
+  [r.Blank]: () => null,
+  [r.Rand]: (c, $, a, s) => h[p[Math.floor(Math.random() * p.length)]](c, $, a, s),
+  [r.Mosaic]: (c, $, a, s) => h[Math.random() > 0.8 ? r.Blank : r.Square](c, $, a, s),
+  [r.MosaicCircle]: (c, $, a, s) => h[Math.random() > 0.8 ? r.Blank : r.Circle](c, $, a, s),
+  [r.MosaicDiamond]: (c, $, a, s) => h[Math.random() > 0.8 ? r.Blank : r.Diamond](c, $, a, s),
+  [r.Square]: (c, $, a, s) => /* @__PURE__ */ n(
+    "rect",
+    {
+      x: a * c,
+      y: a * $,
+      width: a * s.scale,
+      height: a * s.scale,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.Circle]: (c, $, a, s) => /* @__PURE__ */ n(
+    "circle",
+    {
+      cx: a * (c + 0.5 * s.scale),
+      cy: a * ($ + 0.5 * s.scale),
+      r: a / 2 * s.scale,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.Diamond]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + 0.5 * s.scale)} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + 0.5 * s.scale)} 
+      L ${a * (c + 0.5 * s.scale)} ${a * ($ + s.scale)} 
+      L ${a * c} ${a * ($ + 0.5 * s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.Hexagon]: (c, $, a, s) => {
+    const d = a / Math.sqrt(3), N = (a - d) / 2;
+    return /* @__PURE__ */ n(
+      "path",
+      {
+        rotate: 45,
+        d: `M ${a * c + N * s.scale} ${a * $}
+        L ${a * c + (N + d) * s.scale} ${a * $}
+        L ${a * (c + s.scale)} ${a * ($ + 0.5 * s.scale)}
+        L ${a * c + (N + d) * s.scale} ${a * ($ + s.scale)}
+        L ${a * c + N * s.scale} ${a * ($ + s.scale)}
+        L ${a * c} ${a * ($ + 0.5 * s.scale)}  Z`,
+        className: m("fill-current stroke-none", s?.className)
+      },
+      `tile-${c}-${$}`
+    );
+  },
+  [r.RandBasic]: (c, $, a, s) => h[r.Square + Math.floor(Math.random() * 4)](c, $, a, s),
+  [r.TriangleSE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + s.scale)} ${a * $} 
+      L ${a * c} ${a * ($ + s.scale)} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleSW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)} 
+      L ${a * c} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleNW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + s.scale)} ${a * $} 
+      L ${a * c} ${a * ($ + s.scale)} 
+      L ${a * c} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleNE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)} 
+      L ${a * (c + s.scale)} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleRand]: (c, $, a, s) => h[r.TriangleSE + Math.floor(Math.random() * 4)](
+    c,
+    $,
+    a,
+    s
+  ),
+  [r.CaretN]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * ($ + s.scale)} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)} 
+      L ${a * (c + 0.5 * s.scale)} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + 0.5 * s.scale)} 
+      L ${a * c} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretS]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * $} 
+      L ${a * (c + 0.5 * s.scale)} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + s.scale)} ${a * $} 
+      L ${a * c} ${a * ($ + 0.5 * s.scale)} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretRand]: (c, $, a, s) => h[r.CaretN + Math.floor(Math.random() * 4)](c, $, a, s),
+  [r.PieSE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * s.scale + a * c} ${a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * c} ${a * s.scale + a * $} 
+      L ${a * s.scale + a * c} ${a * s.scale + a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieSW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * s.scale + a * c} ${a * s.scale + a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * c} ${a * $} 
+      L ${a * c} ${a * s.scale + a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieNW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * s.scale + a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * s.scale + a * c} ${a * $} 
+      L ${a * c} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieNE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * s.scale + a * c} ${a * s.scale + a * $} 
+      L ${a * s.scale + a * c} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieRand]: (c, $, a, s) => h[r.PieSE + Math.floor(Math.random() * 4)](c, $, a, s)
+}, o = (c, $, a) => {
+  const s = [];
+  for (let d = 0; d < $; d++) {
+    s[d] = [];
+    for (let N = 0; N < c; N++)
+      s[d].push(a);
+  }
+  return s;
+}, T = (c, $, a) => c.map(
+  (s, d) => s.map((N, L) => {
+    const M = typeof N == "object" ? { className: m(a, N.className), scale: N.scale ?? 1, shape: N.shape } : { className: a, scale: 1, shape: N };
+    return h[M.shape](L, d, $, M);
+  })
+).flat();
+export {
+  r as T,
+  o as a,
+  T as g
+};

package/dist/icon-generator.js

@@ -1,303 +1,76 @@
-import { jsx as h } from "react/jsx-runtime";
-import { useMemo as M } from "react";
-import { c as d } from "./utils-CRiPKpXj.js";
-const $ = {
-  Blank: 0,
-  Rand: 1,
-  Mosaic: 2,
-  MosaicCircle: 3,
-  MosaicDiamond: 4,
-  Square: 6,
-  Circle: 7,
-  Diamond: 8,
-  Hexagon: 9,
-  RandBasic: 10,
-  TriangleSE: 11,
-  TriangleSW: 12,
-  TriangleNW: 13,
-  TriangleNE: 14,
-  TriangleRand: 15,
-  CaretN: 16,
-  CaretE: 17,
-  CaretS: 18,
-  CaretW: 19,
-  CaretRand: 20,
-  PieSE: 21,
-  PieSW: 22,
-  PieNW: 23,
-  PieNE: 24,
-  PieRand: 25
-}, p = [
-  $.Square,
-  $.Circle,
-  $.Diamond,
-  $.Hexagon,
-  $.TriangleSE,
-  $.TriangleSW,
-  $.TriangleNW,
-  $.TriangleNE,
-  $.PieSE,
-  $.PieSW,
-  $.PieNW,
-  $.PieNE
-], N = {
-  [$.Blank]: () => null,
-  [$.Rand]: (c, r, a, s) => N[p[Math.floor(Math.random() * p.length)]](c, r, a, s),
-  [$.Mosaic]: (c, r, a, s) => N[Math.random() > 0.8 ? $.Blank : $.Square](c, r, a, s),
-  [$.MosaicCircle]: (c, r, a, s) => N[Math.random() > 0.8 ? $.Blank : $.Circle](c, r, a, s),
-  [$.MosaicDiamond]: (c, r, a, s) => N[Math.random() > 0.8 ? $.Blank : $.Diamond](c, r, a, s),
-  [$.Square]: (c, r, a, s) => /* @__PURE__ */ h(
-    "rect",
-    {
-      x: a * c,
-      y: a * r,
-      width: a * s.scale,
-      height: a * s.scale,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.Circle]: (c, r, a, s) => /* @__PURE__ */ h(
-    "circle",
-    {
-      cx: a * (c + 0.5 * s.scale),
-      cy: a * (r + 0.5 * s.scale),
-      r: a / 2 * s.scale,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.Diamond]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * (c + 0.5 * s.scale)} ${a * r} 
-      L ${a * (c + s.scale)} ${a * (r + 0.5 * s.scale)} 
-      L ${a * (c + 0.5 * s.scale)} ${a * (r + s.scale)} 
-      L ${a * c} ${a * (r + 0.5 * s.scale)}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.Hexagon]: (c, r, a, s) => {
-    const o = a / Math.sqrt(3), m = (a - o) / 2;
-    return /* @__PURE__ */ h(
-      "path",
-      {
-        rotate: 45,
-        d: `M ${a * c + m * s.scale} ${a * r}
-        L ${a * c + (m + o) * s.scale} ${a * r}
-        L ${a * (c + s.scale)} ${a * (r + 0.5 * s.scale)}
-        L ${a * c + (m + o) * s.scale} ${a * (r + s.scale)}
-        L ${a * c + m * s.scale} ${a * (r + s.scale)}
-        L ${a * c} ${a * (r + 0.5 * s.scale)}  Z`,
-        className: d("fill-current stroke-none", s?.className)
-      },
-      `tile-${c}-${r}`
-    );
-  },
-  [$.RandBasic]: (c, r, a, s) => N[$.Square + Math.floor(Math.random() * 4)](c, r, a, s),
-  [$.TriangleSE]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * (c + s.scale)} ${a * r} 
-      L ${a * c} ${a * (r + s.scale)} 
-      L ${a * (c + s.scale)} ${a * (r + s.scale)}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.TriangleSW]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * c} ${a * r} 
-      L ${a * (c + s.scale)} ${a * (r + s.scale)} 
-      L ${a * c} ${a * (r + s.scale)}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.TriangleNW]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * (c + s.scale)} ${a * r} 
-      L ${a * c} ${a * (r + s.scale)} 
-      L ${a * c} ${a * r}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.TriangleNE]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * c} ${a * r} 
-      L ${a * (c + s.scale)} ${a * (r + s.scale)} 
-      L ${a * (c + s.scale)} ${a * r}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.TriangleRand]: (c, r, a, s) => N[$.TriangleSE + Math.floor(Math.random() * 4)](
-    c,
-    r,
-    a,
-    s
-  ),
-  [$.CaretN]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * c} ${a * (r + s.scale)} 
-      L ${a * (c + s.scale)} ${a * (r + s.scale)} 
-      L ${a * (c + 0.5 * s.scale)} ${a * r}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.CaretE]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * c} ${a * r} 
-      L ${a * (c + s.scale)} ${a * (r + 0.5 * s.scale)} 
-      L ${a * c} ${a * (r + s.scale)}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.CaretS]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * c} ${a * r} 
-      L ${a * (c + s.scale)} ${a * r} 
-      L ${a * (c + 0.5 * s.scale)} ${a * (r + s.scale)}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.CaretW]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * (c + s.scale)} ${a * r} 
-      L ${a * c} ${a * (r + 0.5 * s.scale)} 
-      L ${a * (c + s.scale)} ${a * (r + s.scale)}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.CaretRand]: (c, r, a, s) => N[$.CaretN + Math.floor(Math.random() * 4)](c, r, a, s),
-  [$.PieSE]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * s.scale + a * c} ${a * r} 
-      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * c} ${a * s.scale + a * r} 
-      L ${a * s.scale + a * c} ${a * s.scale + a * r}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.PieSW]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * s.scale + a * c} ${a * s.scale + a * r} 
-      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * c} ${a * r} 
-      L ${a * c} ${a * s.scale + a * r}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.PieNW]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * c} ${a * s.scale + a * r} 
-      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * s.scale + a * c} ${a * r} 
-      L ${a * c} ${a * r}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.PieNE]: (c, r, a, s) => /* @__PURE__ */ h(
-    "path",
-    {
-      d: `M ${a * c} ${a * r} 
-      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * s.scale + a * c} ${a * s.scale + a * r} 
-      L ${a * s.scale + a * c} ${a * r}  Z`,
-      className: d("fill-current stroke-none", s?.className)
-    },
-    `tile-${c}-${r}`
-  ),
-  [$.PieRand]: (c, r, a, s) => N[$.PieSE + Math.floor(Math.random() * 4)](c, r, a, s)
-}, w = (c, r, a) => c.map(
-  (s, o) => s.map((m, L) => {
-    const n = typeof m == "object" ? { className: d(a, m.className), scale: m.scale ?? 1, shape: m.shape } : { className: a, scale: 1, shape: m };
-    return N[n.shape](L, o, r, n);
-  })
-).flat(), R = [
-  [$.PieRand, $.PieRand],
-  [$.PieRand, $.PieRand]
+import { jsx as u } from "react/jsx-runtime";
+import { useMemo as r } from "react";
+import { T as o, g as l } from "./generate-tiles-DuagGD1d.js";
+import { c as m } from "./utils-CRiPKpXj.js";
+const k = [
+  [o.PieRand, o.PieRand],
+  [o.PieRand, o.PieRand]
 ];
-function x({
-  pattern: c = R,
-  tileSize: r = 64,
-  tileClassName: a,
-  tileBgClassName: s,
-  renderChildren: o,
-  fit: m = "none",
-  ...L
+function b({
+  pattern: e = k,
+  tileSize: h = 64,
+  tileClassName: s,
+  tileBgClassName: c,
+  renderChildren: d,
+  fit: i = "none",
+  ...g
 }) {
-  const n = M(
+  const t = r(
     () => ({
-      width: c.reduce((u, E) => Math.max(u, E.length), 0) * r,
-      height: c.length * r
+      width: e.reduce((n, v) => Math.max(n, v.length), 0) * h,
+      height: e.length * h
     }),
-    [c, r]
-  ), k = M(() => {
-    const u = w(c, r, a);
-    return s && u.unshift(
-      /* @__PURE__ */ h(
+    [e, h]
+  ), a = r(() => {
+    const n = l(e, h, s);
+    return c && n.unshift(
+      /* @__PURE__ */ u(
         "rect",
         {
           x: 0,
           y: 0,
-          width: n.width,
-          height: n.height,
-          className: d("fill-black stroke-2 stroke-black", s)
+          width: t.width,
+          height: t.height,
+          className: m("fill-black stroke-2 stroke-black", c)
         },
         "svg-mask-invert"
       )
-    ), u;
-  }, [c, n, a, s, r]), P = M(() => {
-    switch (m) {
+    ), n;
+  }, [e, t, s, c, h]), w = r(() => {
+    switch (i) {
       case "fill":
-        return n.width <= n.height ? "100%" : void 0;
+        return t.width <= t.height ? "100%" : void 0;
       case "width":
         return "100%";
       case "none":
-        return n.width;
+        return t.width;
       default:
         return;
     }
-  }, [m, n]), T = M(() => {
-    switch (m) {
+  }, [i, t]), f = r(() => {
+    switch (i) {
       case "fill":
-        return n.height < n.width ? "100%" : void 0;
+        return t.height < t.width ? "100%" : void 0;
       case "height":
         return "100%";
       case "none":
-        return n.height;
+        return t.height;
       default:
         return;
     }
-  }, [m, n]);
-  return /* @__PURE__ */ h(
+  }, [i, t]);
+  return /* @__PURE__ */ u(
     "svg",
     {
-      width: P,
-      height: T,
-      viewBox: `0 0 ${n.width} ${n.height}`,
+      width: w,
+      height: f,
+      viewBox: `0 0 ${t.width} ${t.height}`,
       overflow: "visible",
-      ...L,
-      children: o ? o(k, n.width, n.height) : k
+      ...g,
+      children: d ? d(a, t.width, t.height) : a
     }
   );
 }
 export {
-  x as IconGenerator
+  b as IconGenerator
 };

package/dist/igenerate-tiles.d.ts

@@ -0,0 +1,43 @@
+import { JSX } from 'react';
+
+export declare const generateIconPattern: (width: number, height: number, tileConfig: TileShape | TileConfig) => (TileShape | TileConfig)[][];
+
+export declare const generateTiles: (pattern: (TileShape | TileConfig)[][], tileSize: number, tileClassName?: string) => (JSX.Element | null)[];
+
+declare interface TileConfig {
+    shape: TileShape;
+    scale?: number;
+    className?: string;
+}
+
+declare const TileShape: {
+    readonly Blank: 0;
+    readonly Rand: 1;
+    readonly Mosaic: 2;
+    readonly MosaicCircle: 3;
+    readonly MosaicDiamond: 4;
+    readonly Square: 6;
+    readonly Circle: 7;
+    readonly Diamond: 8;
+    readonly Hexagon: 9;
+    readonly RandBasic: 10;
+    readonly TriangleSE: 11;
+    readonly TriangleSW: 12;
+    readonly TriangleNW: 13;
+    readonly TriangleNE: 14;
+    readonly TriangleRand: 15;
+    readonly CaretN: 16;
+    readonly CaretE: 17;
+    readonly CaretS: 18;
+    readonly CaretW: 19;
+    readonly CaretRand: 20;
+    readonly PieSE: 21;
+    readonly PieSW: 22;
+    readonly PieNW: 23;
+    readonly PieNE: 24;
+    readonly PieRand: 25;
+};
+
+declare type TileShape = (typeof TileShape)[keyof typeof TileShape];
+
+export { }

package/dist/igenerate-tiles.js

@@ -0,0 +1,7 @@
+import "react/jsx-runtime";
+import "./utils-CRiPKpXj.js";
+import { a as o, g as n } from "./generate-tiles-DuagGD1d.js";
+export {
+  o as generateIconPattern,
+  n as generateTiles
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bccampus/ui-components",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "packageManager": "yarn@4.10.3",
   "exports": {
@@ -8,10 +8,18 @@
       "types": "./dist/ui-components.d.ts",
       "import": "./dist/ui-components.js"
     },
+    "./composite": {
+      "types": "./dist/composite.d.ts",
+      "import": "./dist/composite.js"
+    },
     "./icon-generator": {
       "types": "./dist/icon-generator.d.ts",
       "import": "./dist/icon-generator.js"
     },
+    "./generate-tiles": {
+      "types": "./dist/generate-tiles.d.ts",
+      "import": "./dist/generate-tiles.js"
+    },
     "./masked-image-generator": {
       "types": "./dist/masked-image-generator.d.ts",
       "import": "./dist/masked-image-generator.js"
@@ -89,11 +97,14 @@
     "@bcgov/bc-sans": "^2.1.0",
     "@fontsource-variable/inter-tight": "^5.2.7",
     "@ladle/react": "^5.0.3",
+    "@nanostores/react": "^1.0.0",
     "@radix-ui/react-navigation-menu": "^1.2.14",
+    "@radix-ui/react-popover": "^1.1.15",
     "@radix-ui/react-slot": "^1.2.3",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^0.544.0",
+    "nanostores": "^1.0.1",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
     "tailwind-merge": "^3.3.1",